features

var AlertFeature = &Block{
	BaseFeature: BaseFeature{
		Type:          "alert",
		JSConstructor: "Alert",
		JSFiles: []string{
			"editorjs/js/deps/tools/vishaltelangre.editorjs-alert.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string { return d.Data["message"].(string) }
			return fb
		},
		Validate: func(bd editor.BlockData) error {
			var data = bd.Data
			var typ, hasType = data["type"]
			if !hasType {
				return fmt.Errorf("type is required for alert feature")
			}
			if typ == nil || typ == "" {
				return fmt.Errorf("type cannot be empty for alert feature")
			}
			if _, ok := alertTypes[typ.(string)]; !ok {
				return fmt.Errorf("invalid type %s for alert feature", typ)
			}
			return nil
		},
	},
	RenderFunc: templRender(renderAlert),
}

var AlignmentBlockTune = &BlockTune{
	BaseFeature: BaseFeature{
		Type:          "text-align",
		JSConstructor: "AlignmentBlockTune",
		JSFiles: []string{
			"editorjs/js/deps/tools/text-alignment.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string { return d.Data["text"].(string) }
			return fb
		},
	},
	TuneFunc: tuneBlocks,
}

var BackgroundColorTune = &BlockTune{
	BaseFeature: BaseFeature{
		Type:          "background-color",
		JSConstructor: "BackgroundColorTune",
		CSSFiles: []string{
			"editorjs/css/color-tune.css",
		},
		JSFiles: []string{
			"editorjs/js/deps/tools/color-tune.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string { return d.Data["text"].(string) }
			return fb
		},
	},
	TuneFunc: colorTune("background-color"),
}

var DelimiterFeature = &Block{
	BaseFeature: BaseFeature{
		Type:          "delimiter",
		JSConstructor: "Delimiter",
		JSFiles: []string{
			"editorjs/js/deps/tools/delimiter.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(editor.BlockData) string { return "----" }
			return fb
		},
	},
	RenderFunc: renderDelimiter,
}

var (
	ErrRenderNotImplemented = errors.New("feature does not implement RenderBlock")
)

var HeadingFeature = &Block{
	BaseFeature: BaseFeature{
		Type:          "header",
		JSConstructor: "Header",
		JSFiles: []string{
			"editorjs/js/deps/tools/header.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string { return d.Data["text"].(string) }
			return fb
		},
	},
	RenderFunc: renderHeading,
}

var HotkeyFeature = &InlineFeature{
	TagName:    "kbd",
	Class:      "editorjs-inline-hotkey",
	Attributes: []InlineFeatureAttribute{},
	BaseFeature: BaseFeature{
		Type:          "hotkey",
		JSConstructor: "EditorJSInlineHotkey",
		JSFiles: []string{
			"editorjs/js/deps/tools/hotkey.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string {
				return fmt.Sprintf("[%s](%s)", d.Data["text"], d.Data["id"])
			}
			return fb
		},
	},
	RebuildElementsFn: func(li []*InlineFeatureElement) error {
		for _, el := range li {
			el.Node.Attr = []html.Attribute{
				{
					Key: "class",
					Val: "hotkey",
				},
			}
		}

		return nil
	},
}

var InlineCodeFeature = &InlineFeature{
	TagName:    "span",
	Class:      "inline-code",
	Attributes: []InlineFeatureAttribute{},
	BaseFeature: BaseFeature{
		Type:          "inline-code",
		JSConstructor: "InlineCode",
		JSFiles: []string{
			"editorjs/js/deps/tools/inline-code.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string {
				return fmt.Sprintf("[%s](%s)", d.Data["text"], d.Data["id"])
			}
			return fb
		},
	},
	RebuildElementsFn: func(li []*InlineFeatureElement) error {
		for _, el := range li {
			el.Node.Attr = []html.Attribute{
				{
					Key: "class",
					Val: "inline-code",
				},
			}
		}

		return nil
	},
}

var ListBlock = &Block{
	BaseFeature: BaseFeature{
		Type:          "list",
		JSConstructor: "EditorjsList",
		JSFiles: []string{
			"editorjs/js/deps/tools/list@2.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			return fb
		},
	},
	RenderFunc: func(b editor.FeatureBlock, c context.Context, w io.Writer) error {
		var data = b.Data().Data
		var out = &listOutput{
			Items: make([]listItem, 0),
		}

		style, ok := data["style"].(string)
		if ok {
			out.Style = style
		}

		meta, ok := data["meta"].(map[string]interface{})
		if ok {
			start, _ := meta["start"].(int)
			counterType, _ := meta["counterType"].(string)
			out.Meta = listItemMeta{
				Start:       start,
				CounterType: counterType,
			}
		}

		items, ok := data["items"].([]interface{})
		if ok {
			out.Items = parseItems(items)
		}

		return renderList(b, out).Render(c, w)
	},
}

var MarkerFeature = &InlineFeature{
	TagName:    "mark",
	Class:      "cdx-marker",
	Attributes: []InlineFeatureAttribute{},
	BaseFeature: BaseFeature{
		Type:          "marker",
		JSConstructor: "Marker",
		JSFiles: []string{
			"editorjs/js/deps/tools/marker.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string {
				return fmt.Sprintf("[%s](%s)", d.Data["text"], d.Data["id"])
			}
			return fb
		},
	},
	RebuildElementsFn: func(li []*InlineFeatureElement) error {
		for _, el := range li {
			el.Node.Attr = []html.Attribute{
				{
					Key: "class",
					Val: "marker",
				},
			}
		}

		return nil
	},
}

var ParagraphFeature = &Block{
	BaseFeature: BaseFeature{
		Type:          "paragraph",
		JSConstructor: "Paragraph",
		JSFiles: []string{
			"editorjs/js/deps/tools/paragraph.umd.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string { return d.Data["text"].(string) }
			return fb
		},
	},
	RenderFunc: renderParagraph,
}

var StrikeThroughFeature = &InlineFeature{
	TagName:    "s",
	Class:      "cdx-strikethrough",
	Attributes: []InlineFeatureAttribute{},
	BaseFeature: BaseFeature{
		Type:          "strikethrough",
		JSConstructor: "Strikethrough",
		JSFiles: []string{
			"editorjs/js/deps/tools/strikethrough.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string {
				return fmt.Sprintf("[%s](%s)", d.Data["text"], d.Data["id"])
			}
			return fb
		},
	},
	RebuildElementsFn: func(li []*InlineFeatureElement) error {
		for _, el := range li {
			el.Node.Attr = []html.Attribute{
				{
					Key: "class",
					Val: "strikethrough",
				},
			}
		}

		return nil
	},
}

var TableFeature = &Block{
	BaseFeature: BaseFeature{
		Type:          "table",
		JSConstructor: "Table",
		JSFiles: []string{
			"editorjs/js/deps/tools/table.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string { return "Table" }
			return fb
		},
		Validate: func(bd editor.BlockData) error {
			var data = bd.Data
			var content, hasContent = data["content"]
			if !hasContent {
				return fmt.Errorf("content is required for table feature")
			}
			var _, isArray = content.([]interface{})
			if !isArray {
				return fmt.Errorf("content should be an array of arrays")
			}
			return nil
		},
	},
	RenderFunc: templRender(renderTable),
}

var TextColorTune = &BlockTune{
	BaseFeature: BaseFeature{
		Type:          "text-color",
		JSConstructor: "TextColorTune",
		CSSFiles: []string{
			"editorjs/css/color-tune.css",
		},
		JSFiles: []string{
			"editorjs/js/deps/tools/color-tune.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string { return d.Data["text"].(string) }
			return fb
		},
	},
	TuneFunc: colorTune("text-color"),
}

var UnderlineFeature = &InlineFeature{
	TagName:    "u",
	Class:      "cdx-underline",
	Attributes: []InlineFeatureAttribute{},
	BaseFeature: BaseFeature{
		Type:          "underline",
		JSConstructor: "Underline",
		JSFiles: []string{
			"editorjs/js/deps/tools/underline.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			fb.GetString = func(d editor.BlockData) string {
				return fmt.Sprintf("[%s](%s)", d.Data["text"], d.Data["id"])
			}
			return fb
		},
	},
	RebuildElementsFn: func(li []*InlineFeatureElement) error {
		for _, el := range li {
			el.Node.Attr = []html.Attribute{
				{
					Key: "class",
					Val: "underline",
				},
			}
		}

		return nil
	},
}