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",
		CSSFles: []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", func(fb editor.FeatureBlock, data map[string]interface{}) {
		if a, ok := data["stretched"]; ok {
			fb.Class("background-stretched")
			fb.Attribute("data-stretched", a)
		}
	}),
}

var CheckListBlock = &Block{
	BaseFeature: BaseFeature{
		Type:          "checklist",
		JSConstructor: "Checklist",
		JSFiles: []string{
			"editorjs/js/deps/tools/checklist.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			return fb
		},
	},
	RenderFunc: func(b editor.FeatureBlock, c context.Context, w io.Writer) error {
		var items = make([]checkListItem, 0)
		var checklistItems = b.Data().Data["items"].([]interface{})
		for _, item := range checklistItems {
			item := item.(map[string]interface{})
			items = append(items, checkListItem{
				Text:    item["text"].(string),
				Checked: item["checked"].(bool),
			})
		}
		return renderCheckList(b, items).Render(c, w)
	},
}

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 ListBlock = &Block{
	BaseFeature: BaseFeature{
		Type:          "list",
		JSConstructor: "List",
		JSFiles: []string{
			"editorjs/js/deps/tools/list.js",
		},
		Build: func(fb *FeatureBlock) *FeatureBlock {
			return fb
		},
	},
	RenderFunc: func(b editor.FeatureBlock, c context.Context, w io.Writer) error {
		var items = make([]string, 0)
		for _, item := range b.Data().Data["items"].([]interface{}) {
			items = append(items, item.(string))
		}
		return renderList(b, items).Render(c, w)
	},
}

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 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",
		CSSFles: []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", nil),
}