@cloudcannon/configuration-types 0.0.42 → 0.0.44

package/src/preview.ts

@@ -1,144 +1,79 @@
 import * as z from 'zod';
 
-const PreviewKeyEntrySchema = z.object({
-	key: z.string().meta({
-		description: 'The key used to access the value used for the preview.',
-	}),
-});
+const PreviewKeyEntrySchema = z
+	.object({ key: z.string().meta({ title: 'Key Value' }) })
+	.meta({ title: 'Key' });
 
-const PreviewTemplateEntrySchema = z.object({
-	template: z.string().meta({
-		description:
-			'A template string containing various placeholders for the value used in the preview.',
-	}),
-});
+const PreviewTemplateEntrySchema = z
+	.object({ template: z.string().meta({ title: 'Template Value' }) })
+	.meta({ title: 'Template' });
 
-const PreviewTextEntrySchema = z.object({
-	text: z.string().meta({
-		description: 'The raw text used as the value for the preview.',
-	}),
-});
+const PreviewTextEntrySchema = z
+	.object({ text: z.string().meta({ title: 'Text Value' }) })
+	.meta({ title: 'Text' });
+
+const PreviewRawTextEntrySchema = z.string().meta({ title: 'Raw Text' });
+const PreviewFalseEntrySchema = z.literal(false).meta({ title: 'False' });
 
 const PreviewEntrySchema = z
 	.union([
 		PreviewKeyEntrySchema,
 		PreviewTemplateEntrySchema,
 		PreviewTextEntrySchema,
-		z.string(),
-		z.literal(false),
+		PreviewRawTextEntrySchema,
+		PreviewFalseEntrySchema,
 	])
-	.meta({
-		id: 'PreviewEntry',
-	});
-
-const PreviewEntriesSchema = z
-	.union([z.array(PreviewEntrySchema), z.string(), z.literal(false)])
-	.meta({
-		id: 'PreviewEntries',
-	});
-
-const TextPreviewSchema = PreviewEntriesSchema.meta({
-	id: 'preview.text',
-	description: 'Controls the main text shown per item.',
-});
-
-const ImagePreviewSchema = PreviewEntriesSchema.meta({
-	id: 'preview.image',
-	description: 'Controls the image shown per item.',
-});
-
-const IconPreviewSchema = PreviewEntriesSchema.meta({
-	id: 'preview.icon',
-	description: 'Controls the icon shown per item. Must result in a Material Symbol name.',
-});
-
-export const IconColorSchema = PreviewEntriesSchema.meta({
-	id: 'preview.icon_color',
-	description: 'Controls the color of the icon.',
-});
+	.meta({ id: 'PreviewEntry' });
 
-export const IconBackgroundColorSchema = PreviewEntriesSchema.meta({
-	id: 'preview.icon_background_color',
-	description: 'Controls the background color of the icon.',
-});
+export const PreviewEntriesSchema = z
+	.union([
+		z.array(PreviewEntrySchema).meta({ title: 'Array' }),
+		PreviewRawTextEntrySchema,
+		PreviewFalseEntrySchema,
+	])
+	.meta({ id: 'PreviewEntries' });
 
 export const PreviewGallerySchema = z
 	.object({
-		text: TextPreviewSchema.optional(),
-		image: ImagePreviewSchema.optional(),
-		icon: IconPreviewSchema.optional(),
-		icon_color: IconColorSchema.optional(),
-		icon_background_color: IconBackgroundColorSchema.optional(),
-		fit: z.enum(['padded', 'cover', 'contain', 'cover-top']).default('padded').optional().meta({
-			description: 'Controls how the gallery image is positioned within the gallery.',
-		}),
-		background_color: PreviewEntriesSchema.optional().meta({
-			description: 'Controls the background color gallery area.',
-		}),
+		text: PreviewEntriesSchema.optional(),
+		image: PreviewEntriesSchema.optional(),
+		icon: PreviewEntriesSchema.optional(),
+		icon_color: PreviewEntriesSchema.optional(),
+		icon_background_color: PreviewEntriesSchema.optional(),
+		fit: z
+			.enum(['padded', 'cover', 'contain', 'cover-top'])
+			.default('padded')
+			.optional()
+			.meta({ id: 'preview.gallery.fit' }),
+		background_color: PreviewEntriesSchema.optional(),
 	})
-	.meta({
-		id: 'preview.gallery',
-		title: 'Preview Gallery',
-		description: 'Configuration for gallery-style previews.',
-	});
+	.meta({ id: 'preview.gallery' });
 
-export const PreviewMetadataSchema = z
+const PreviewMetadataEntrySchema = z
 	.object({
-		text: TextPreviewSchema.optional(),
-		image: ImagePreviewSchema.optional(),
-		icon: IconPreviewSchema.optional(),
-		icon_color: IconColorSchema.optional(),
-		icon_background_color: IconBackgroundColorSchema.optional(),
+		text: PreviewEntriesSchema.optional(),
+		image: PreviewEntriesSchema.optional(),
+		icon: PreviewEntriesSchema.optional(),
+		icon_color: PreviewEntriesSchema.optional(),
+		icon_background_color: PreviewEntriesSchema.optional(),
 	})
-	.meta({
-		id: 'preview.metadata',
-		title: 'Preview Metadata',
-		description:
-			'Metadata configuration for preview items including text, image, and icon options.',
-	});
+	.meta({ id: 'PreviewMetadataEntry' });
 
 export const PreviewSchema = z
 	.object({
-		text: TextPreviewSchema.optional(),
-		subtext: PreviewEntriesSchema.optional().meta({
-			description: 'Controls the supporting text shown per item.',
-		}),
-		image: ImagePreviewSchema.optional(),
-		icon: IconPreviewSchema.optional(),
-		icon_color: IconColorSchema.optional(),
-		icon_background_color: IconBackgroundColorSchema.optional(),
-		tags: z.array(z.string()).optional().meta({
-			description: 'Defines a list of tags.',
-		}),
-		metadata: z.array(PreviewMetadataSchema).optional().meta({
-			description: 'Defines a list of items that can contain an image, icon, and text.',
-		}),
-		gallery: PreviewGallerySchema.optional().meta({
-			description: 'Details for large image/icon preview per item.',
-		}),
-	})
-	.meta({
-		id: 'preview',
-		title: 'Preview',
-		description:
-			'Configuration for how content items are visually previewed in the CloudCannon interface.',
-	});
-
-export const PickerPreviewSchema = z
-	.object({
-		// This needs to extend it this way, rather than calling PreviewSchema.meta({}).
-		// Otherwise, it seems to override in a way that does not allow us to remove `"id": "preview"`
-		// during JSONSchema generate.
-		...PreviewSchema.shape,
+		text: PreviewEntriesSchema.optional(),
+		subtext: PreviewEntriesSchema.optional(),
+		image: PreviewEntriesSchema.optional(),
+		icon: PreviewEntriesSchema.optional(),
+		icon_color: PreviewEntriesSchema.optional(),
+		icon_background_color: PreviewEntriesSchema.optional(),
+		tags: z.array(z.string()).optional().meta({ id: 'preview.tags' }),
+		metadata: z.array(PreviewMetadataEntrySchema).optional().meta({ id: 'preview.metadata' }),
+		gallery: PreviewGallerySchema.optional(),
 	})
-	.meta({
-		id: 'picker_preview',
-		title: 'Picker Preview',
-		description: 'Changes the way items are previewed in the CMS while being chosen.',
-	});
+	.meta({ id: 'type.preview', title: 'Preview' });
 
 export type PreviewEntry = z.infer<typeof PreviewEntrySchema>;
 export type PreviewEntries = z.infer<typeof PreviewEntriesSchema>;
 export type PreviewGallery = z.infer<typeof PreviewGallerySchema>;
-export type PreviewMetadata = z.infer<typeof PreviewMetadataSchema>;
 export type Preview = z.infer<typeof PreviewSchema>;

package/src/select-values.ts

@@ -2,21 +2,18 @@ import * as z from 'zod';
 
 export const SelectDataValuesSchema = z
 	.union([
-		z.array(z.string()),
-		z.array(z.record(z.string(), z.string())),
-		z.record(z.string(), z.string()),
-		z.array(z.record(z.string(), z.unknown())),
-		z.record(z.string(), z.unknown()),
+		z.array(z.string()).meta({ title: 'Text Array' }),
+		z.record(z.string(), z.string()).meta({ title: 'Text Object' }),
+		z.array(z.record(z.string(), z.unknown())).meta({ title: 'Object Array' }),
+		z.record(z.string(), z.unknown()).meta({ title: 'Object' }),
 	])
 	.meta({
-		id: 'SelectDataValues',
-		title: 'Select Data Values',
 		description:
 			'Data formats for populating select and multiselect input options, supporting arrays and objects.',
 	});
 
 export const SelectDataSchema = z.record(z.string(), SelectDataValuesSchema).meta({
-	id: '_select_data',
+	id: 'type._select_data',
 	title: 'Select Data',
 	description:
 		'Fixed datasets that can be referenced by the _Values_ configuration for _Select_ and _Multiselect_ inputs.',

package/src/snippets.ts

@@ -1,22 +1,192 @@
 import * as z from 'zod';
-import { ReducedCascadeSchema } from './cascade';
-import { PickerPreviewSchema, PreviewSchema } from './preview';
+import { ReducedCascadeSchema } from './cascade.ts';
+import { PreviewSchema } from './preview.ts';
+
+export const ParserModelSchema = z.object({
+	source_key: z.string().optional(),
+	editor_key: z.string().optional(),
+	remove_empty: z.boolean(),
+	optional: z.boolean(),
+	type: z.enum(['array', 'object', 'string', 'boolean', 'number']).optional(),
+	allowed_values: z.array(z.any()).optional(),
+	implied_boolean: z.boolean(),
+	default: z.any().optional(),
+});
+
+export const PairedTokenSchema = z.object({
+	start: z.string(),
+	end: z.string(),
+});
+
+export const StringCasesSchema = z.object({
+	any: z.boolean().optional(),
+	leading_upper: z.boolean().optional(),
+	leading_lower: z.boolean().optional(),
+	lower: z.boolean().optional(),
+	upper: z.boolean().optional(),
+});
+
+export const SnippetStyleSchema = z.object({
+	output: z.enum(['legacy', 'inline', 'block']),
+	inline: z
+		.object({
+			leading: z.string().optional(),
+			trailing: z.string().optional(),
+		})
+
+		.optional(),
+	block: z
+		.object({
+			leading: z.string().optional(),
+			trailing: z.string().optional(),
+			indent: z.string().optional(),
+		})
+
+		.optional(),
+});
+
+export const ParserFormatSchema = z.object({
+	root_boundary: PairedTokenSchema,
+	root_value_boundary: PairedTokenSchema,
+	root_value_boundary_optional: z.record(z.string(), z.boolean()),
+	root_value_delimiter: z.string().optional(),
+	root_pair_delimiter: z.array(z.string()),
+	remove_empty_root_boundary: z.boolean(),
+	object_boundary: PairedTokenSchema,
+	object_value_delimiter: z.string(),
+	object_pair_delimiter: z.string(),
+	array_boundary: PairedTokenSchema,
+	array_delimiter: z.string(),
+	string_boundary: z.array(z.string()),
+	string_escape_character: z.string(),
+	allow_booleans: z.boolean(),
+	allow_numbers: z.boolean(),
+	allow_implied_values: z.boolean(),
+	allow_null: z.boolean(),
+	forbidden_tokens: z.array(z.string()),
+	allowed_string_cases: StringCasesSchema,
+});
+
+export const ArgumentListParserConfigSchema = z.object({
+	parser: z.literal('argument_list'),
+	options: z.object({
+		models: z.array(ParserModelSchema),
+		format: ParserFormatSchema,
+	}),
+});
+
+export const ArgumentParserConfigSchema = z.object({
+	parser: z.literal('argument'),
+	options: z.object({
+		model: ParserModelSchema,
+		format: ParserFormatSchema,
+	}),
+});
+
+export const ContentParserConfigSchema = z.object({
+	parser: z.literal('content'),
+	options: z.object({
+		editor_key: z.string().optional(),
+		indented_by: z.string().optional(),
+		default: z.string().optional(),
+		trim_text: z.boolean().optional(),
+		allow_nested: z.boolean().optional(),
+		raw: z.boolean().optional(),
+		forbidden_tokens: z.array(z.string()).optional(),
+		optional: z.boolean().optional(),
+		allow_leading: z.boolean().optional(),
+		escape_indented_blocks: z.boolean().default(false).optional(),
+		parse_newline_character: z.boolean().default(false).optional(),
+		ignore_unpaired_backticks: z.boolean().default(true).optional(),
+		escape_fenced_blocks: z.boolean().default(false).optional(),
+		style: SnippetStyleSchema.optional(),
+	}),
+});
+
+export const KeyValueListParserConfigSchema = z.object({
+	parser: z.literal('key_values'),
+	options: z.object({
+		models: z.array(ParserModelSchema),
+		format: ParserFormatSchema,
+		style: SnippetStyleSchema,
+	}),
+});
+
+export const LiteralParserConfigSchema = z.object({
+	parser: z.literal('literal'),
+	options: z.object({
+		literal: z.string(),
+		format: z.object({ string_boundary: z.array(z.string()).optional() }).optional(),
+	}),
+});
+
+export const OptionalParserConfigSchema = z.object({
+	parser: z.literal('optional'),
+	options: z.object({
+		snippet: z.string(),
+		remove_empty: z.boolean().optional(),
+	}),
+});
+
+export const RepeatingLiteralParserConfigSchema = z.object({
+	parser: z.literal('repeating_literal'),
+	options: z.object({
+		literal: z.string(),
+		default: z.number(),
+		minimum: z.number(),
+		editor_key: z.string().optional(),
+	}),
+});
+
+export const RepeatingParserConfigSchema = z.object({
+	parser: z.literal('repeating'),
+	options: z.object({
+		snippet: z.string(),
+		editor_key: z.string().optional(),
+		output_delimiter: z.string().optional(),
+		default_length: z.number().optional(),
+		style: SnippetStyleSchema.optional(),
+		optional: z.boolean().optional(),
+	}),
+});
+
+export const WrapperParserConfigSchema = z.object({
+	parser: z.literal('wrapper'),
+	options: z.object({
+		snippet: z.string(),
+		remove_empty: z.boolean().optional(),
+		style: SnippetStyleSchema.optional(),
+	}),
+});
+
+export const ParserConfigSchema = z.union([
+	ArgumentListParserConfigSchema.meta({ title: 'Argument List Parser Config' }),
+	ArgumentParserConfigSchema.meta({ title: 'Argument Parser Config' }),
+	ContentParserConfigSchema.meta({ title: 'Content Parser Config' }),
+	KeyValueListParserConfigSchema.meta({ title: 'Key Value List Parser Config' }),
+	LiteralParserConfigSchema.meta({ title: 'Literal Parser Config' }),
+	OptionalParserConfigSchema.meta({ title: 'Optional Parser Config' }),
+	RepeatingLiteralParserConfigSchema.meta({ title: 'Repeating Literal Parser Config' }),
+	RepeatingParserConfigSchema.meta({ title: 'Repeating Parser Config' }),
+	WrapperParserConfigSchema.meta({ title: 'Wrapper Parser Config' }),
+]);
 
 export const SnippetConfigSchema = z
 	.object({
 		...ReducedCascadeSchema.shape,
 		preview: PreviewSchema.optional(),
-		picker_preview: PickerPreviewSchema.optional(),
+		picker_preview: PreviewSchema.optional(),
 	})
 	.extend({
 		snippet: z.string().optional().meta({
-			description: 'Name of the snippet.',
+			description:
+				'The snippet string contains the text to match for your snippet, with any dynamic sections represented using a placeholder in double square brackets.',
 		}),
 		template: z.string().optional().meta({
 			description:
-				'The template that this snippet should inherit, out of the available Shortcode Templates.',
+				'The template that this snippet should inherit, out of the available Snippet Templates.',
 		}),
-		inline: z.boolean().optional().meta({
+		inline: z.boolean().default(false).optional().meta({
 			description:
 				'Whether this snippet can appear inline (within a sentence). Defaults to false, which will treat this snippet as a block-level element in the content editor.',
 		}),
@@ -32,82 +202,81 @@ export const SnippetConfigSchema = z
 		}),
 		get alternate_formats() {
 			return z.array(SnippetConfigSchema).optional().meta({
+				id: 'SnippetAlternateFormats',
 				description: 'Alternate configurations for this snippet.',
 			});
 		},
-		params: z.record(z.string(), z.unknown()).optional().meta({
+		params: z.record(z.string(), ParserConfigSchema).optional().meta({
+			title: 'Parser Config',
 			description: 'The parameters of this snippet.',
 		}),
 	})
 	.meta({
-		id: 'SnippetConfig',
-		title: 'Snippet Configuration',
+		id: 'type.snippet',
+		title: 'Snippet',
 		description: 'A snippet configuration.',
 	});
 
 const SnippetImportSchema = z
 	.union([
-		z.boolean(),
-		z.object({
-			exclude: z.array(z.string()).meta({
-				description:
-					'The list of excluded snippets. If unset, all snippets are excluded unless defined in `include`.',
-			}),
-		}),
-		z.object({
-			include: z.array(z.string()).meta({
-				description:
-					'The list of included snippets. If unset, all snippets are included unless defined in `exclude`.',
-			}),
-		}),
+		z.boolean().meta({ title: 'Full Import' }),
+		z
+			.object({
+				exclude: z.array(z.string()).meta({
+					id: 'SnippetImportExclude',
+					description:
+						'The list of excluded snippets. If unset, all snippets are excluded unless defined in `include`.',
+				}),
+			})
+			.meta({ title: 'Exclude List' }),
+		z
+			.object({
+				include: z.array(z.string()).meta({
+					id: 'SnippetImportInclude',
+					description:
+						'The list of included snippets. If unset, all snippets are included unless defined in `exclude`.',
+				}),
+			})
+			.meta({ title: 'Include List' }),
 	])
-	.meta({
-		id: 'SnippetImport',
-		title: 'Snippet Import',
-		description: 'Controls what snippets are available to import.',
-	});
+	.optional();
 
 export const SnippetsImportsSchema = z
 	.object({
-		hugo: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for Hugo SSG.',
+		hugo: SnippetImportSchema.meta({
+			id: '_snippets_imports.hugo',
 			uniqueItems: true,
 		}),
-		jekyll: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for Jekyll SSG.',
+		jekyll: SnippetImportSchema.meta({
+			id: '_snippets_imports.jekyll',
 			uniqueItems: true,
 		}),
-		mdx: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for MDX-based content.',
+		mdx: SnippetImportSchema.meta({
+			id: '_snippets_imports.mdx',
 			uniqueItems: true,
 		}),
-		eleventy_liquid: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for Eleventy SSG Liquid files.',
+		eleventy_liquid: SnippetImportSchema.meta({
+			id: '_snippets_imports.eleventy_liquid',
 			uniqueItems: true,
 		}),
-		eleventy_nunjucks: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for Eleventy SSG Nunjucks files.',
+		eleventy_nunjucks: SnippetImportSchema.meta({
+			id: '_snippets_imports.eleventy_nunjucks',
 			uniqueItems: true,
 		}),
-		markdoc: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for Markdoc-based content.',
+		markdoc: SnippetImportSchema.meta({
+			id: '_snippets_imports.markdoc',
 			uniqueItems: true,
 		}),
-		python_markdown_extensions: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for content using Python markdown extensions.',
+		python_markdown_extensions: SnippetImportSchema.meta({
+			id: '_snippets_imports.python_markdown_extensions',
 			uniqueItems: true,
 		}),
-		docusaurus_mdx: SnippetImportSchema.optional().meta({
-			description: 'Default snippets for Docusaurus SSG.',
+		docusaurus_mdx: SnippetImportSchema.meta({
+			id: '_snippets_imports.docusaurus_mdx',
 			uniqueItems: true,
 		}),
 	})
-	.meta({
-		id: '_snippets_imports',
-		title: 'Snippets Imports',
-		description:
-			'Provides control over which snippets are available to use and/or extend within `_snippets`.',
-	});
+	.meta({ id: 'type._snippets_imports', title: 'Snippets Imports' });
 
 export type SnippetConfig = z.infer<typeof SnippetConfigSchema>;
 export type SnippetsImports = z.infer<typeof SnippetsImportsSchema>;

package/src/source-editor.ts

@@ -2,66 +2,39 @@ import * as z from 'zod';
 
 export const ThemeSchema = z
 	.enum([
-		'ambiance',
-		'chaos',
-		'chrome',
-		'clouds',
-		'clouds_midnight',
-		'cobalt',
-		'crimson_editor',
-		'dawn',
+		'atomone',
+		'basic_dark',
+		'basic_light',
+		'darcula',
 		'dracula',
-		'dreamweaver',
+		'duotone_dark',
+		'duotone_light',
 		'eclipse',
-		'github',
-		'gob',
-		'gruvbox',
-		'idle_fingers',
-		'iplastic',
-		'katzenmilch',
-		'kr_theme',
-		'kuroir',
-		'merbivore',
-		'merbivore_soft',
-		'mono_industrial',
-		'monokai',
-		'nord_dark',
-		'pastel_on_dark',
+		'github_dark',
+		'github_light',
+		'gruvbox_dark',
+		'gruvbox_light',
+		'material_dark',
+		'material_light',
 		'solarized_dark',
 		'solarized_light',
-		'sqlserver',
-		'terminal',
-		'textmate',
-		'tomorrow',
-		'tomorrow_night',
+		'sublime',
+		'tokyo_night',
+		'tokyo_night_day',
+		'tokyo_night_storm',
 		'tomorrow_night_blue',
-		'tomorrow_night_bright',
-		'tomorrow_night_eighties',
-		'twilight',
-		'vibrant_ink',
-		'xcode',
+		'vscode_dark',
+		'vscode_light',
+		'xcode_dark',
+		'xcode_light',
 	])
-	.meta({
-		id: 'Theme',
-	});
+	.meta({ id: 'Theme' });
 
 export const SourceEditorSchema = z.object({
-	tab_size: z.number().default(2).optional().meta({
-		description:
-			'This key defines the auto-indentation of each line and how many spaces a tab indentation counts as.\n\nBy default, this key is `2`.\n\nhttps://cloudcannon.com/documentation/articles/the-source-editor/#source_editor.tab_size',
-	}),
-	theme: ThemeSchema.default('monokai').optional().meta({
-		title: 'Theme',
-		description:
-			'This key defines the color theme for syntax highlighting.\n\nBy default, this key is `monokai`.\n\nhttps://cloudcannon.com/documentation/articles/the-source-editor/#source_editor.theme',
-	}),
-	show_gutter: z.boolean().default(true).optional().meta({
-		description:
-			'This key toggles the gutter on the left of the editing interface, displaying line numbers and code folding controls.\n\nBy default, this key is `true`.\n\nhttps://cloudcannon.com/documentation/articles/the-source-editor/#source_editor.show_gutter',
-	}),
-	soft_wrap: z.boolean().default(false).optional().meta({
-		description: 'Enables soft wrapping of the code.',
-	}),
+	tab_size: z.number().default(2).optional(),
+	theme: ThemeSchema.default('basic_dark').optional(),
+	show_gutter: z.boolean().default(true).optional(),
+	soft_wrap: z.boolean().default(false).optional(),
 });
 
 export type Theme = z.infer<typeof ThemeSchema>;