@cloudcannon/configuration-types 0.0.37 → 0.0.38

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@cloudcannon/configuration-types",
-	"version": "0.0.37",
+	"version": "0.0.38",
 	"type": "module",
 	"description": "Contains TypeScript declarations and generates JSONSchema files for the CloudCannon configuration file.",
 	"author": "CloudCannon <support@cloudcannon.com>",
@@ -19,24 +19,22 @@
 		"email": "support@cloudcannon.com"
 	},
 	"scripts": {
-		"prebuild": "rimraf dist && mkdir -p dist",
-		"build": "run-p build:*",
-		"build:combined": "cp src/cloudcannon-config.schema.json dist/cloudcannon-config.schema.json",
-		"build:latest": "ts-json-schema-generator --markdown-description --no-top-ref --path src/index.d.ts --type Configuration --out dist/cloudcannon-config.latest.schema.json --id 'https://github.com/cloudcannon/configuration-types/releases/latest/download/cloudcannon-config.latest.schema.json'",
-		"build:legacy-jekyll": "ts-json-schema-generator --markdown-description --no-top-ref --path src/build-coupled.d.ts --type JekyllConfiguration --out dist/cloudcannon-config.legacy-jekyll.schema.json --id 'https://github.com/cloudcannon/configuration-types/releases/latest/download/cloudcannon-config.legacy-jekyll.schema.json'",
-		"build:legacy-hugo": "ts-json-schema-generator --markdown-description --no-top-ref --path src/build-coupled.d.ts --type HugoConfiguration --out dist/cloudcannon-config.legacy-hugo.schema.json --id 'https://github.com/cloudcannon/configuration-types/releases/latest/download/cloudcannon-config.legacy-hugo.schema.json'",
-		"build:legacy-eleventy": "ts-json-schema-generator --markdown-description --no-top-ref --path src/build-coupled.d.ts --type EleventyConfiguration --out dist/cloudcannon-config.legacy-eleventy.schema.json --id 'https://github.com/cloudcannon/configuration-types/releases/latest/download/cloudcannon-config.legacy-eleventy.schema.json'",
-		"build:legacy-reader": "ts-json-schema-generator --markdown-description --no-top-ref --path src/build-coupled.d.ts --type ReaderConfiguration --out dist/cloudcannon-config.legacy-reader.schema.json --id 'https://github.com/cloudcannon/configuration-types/releases/latest/download/cloudcannon-config.legacy-reader.schema.json'",
+		"prebuild": "rm -rf dist && mkdir -p dist",
+		"build": "tsx generate-schemas.ts && npm run build:combined",
+		"build:combined": "cp cloudcannon-config.schema.json dist/cloudcannon-config.schema.json",
 		"lint": "npm run lint:tsc && npm run lint:format",
 		"lint:tsc": "tsc --noEmit",
-		"lint:format": "prettier -c src",
-		"format": "prettier -w src",
+		"lint:format": "biome check --fix",
+		"lint:report": "biome lint --diagnostic-level=error --reporter=junit > lint-results.xml",
+		"lint:staged": "biome check --diagnostic-level=error --staged --no-errors-on-unmatched",
 		"site:dev": "http-server site -p 12345 -c-1",
 		"site:build": "cp dist/*.schema.json site/.",
-		"test": "exit 0"
+		"test": "vitest run",
+		"test:watch": "vitest",
+		"test:coverage": "vitest run --coverage"
 	},
-	"main": "./src/index.d.ts",
-	"types": "./src/index.d.ts",
+	"main": "./src/index.ts",
+	"types": "./src/index.ts",
 	"publishConfig": {
 		"access": "public"
 	},
@@ -46,15 +44,15 @@
 	],
 	"dependencies": {
 		"@cloudcannon/snippet-types": "^1.1.13",
-		"npm-run-all": "^4.1.5",
-		"ts-json-schema-generator": "^2.2.0"
+		"zod": "^4.0.17"
 	},
 	"devDependencies": {
-		"@types/node": "^22.10.7",
+		"@biomejs/biome": "1.9.4",
+		"@types/node": "^24.2.1",
+		"@vitest/coverage-v8": "^2.1.9",
 		"http-server": "^14.1.1",
-		"prettier": "^3.4.2",
-		"prettier-plugin-jsdoc": "^1.3.2",
-		"rimraf": "^6.0.1",
-		"typescript": "^5.7.3"
+		"tsx": "^4.20.4",
+		"typescript": "^5.9.2",
+		"vitest": "^2.1.8"
 	}
 }

package/src/build-coupled.ts

@@ -0,0 +1,295 @@
+import * as z from 'zod';
+import {
+	CollectionConfigSchema,
+	ConfigurationSchema,
+	DataConfigEntrySchema,
+} from './configuration';
+import { PathsSchema } from './paths';
+
+export const BuildCoupledPathsSchema = z
+	.object({
+		...PathsSchema.shape,
+		collections: z.string().optional().meta({
+			description: 'Parent folder of all collections.',
+		}),
+		data: z.string().optional().meta({
+			description: 'Parent folder of all site data files.',
+		}),
+		layouts: z.string().optional().meta({
+			description:
+				'Parent folder of all site layout files. Only applies to Jekyll, Hugo, and Eleventy sites.',
+		}),
+		includes: z.string().optional().meta({
+			description:
+				'Parent folder of all includes, partials, or shortcode files. Only applies to Jekyll, Hugo, and Eleventy sites.',
+		}),
+	})
+	.meta({
+		id: 'paths:BuildCoupled',
+		description:
+			'Paths to where new asset files are uploaded to. They also set the default path when choosing existing images, and linking to existing files. Each path is relative to global `source`.',
+	});
+
+export const FilterBaseSchema = z.enum(['none', 'all', 'strict']);
+
+export const FilterValueSchema = z.object({
+	base: FilterBaseSchema.optional().meta({
+		description:
+			'Defines the initial set of visible files in the collection file list. Defaults to "all", or "strict" for the auto-discovered `pages` collection in Jekyll, Hugo, and Eleventy.',
+	}),
+	include: z.array(z.string()).optional().meta({
+		description:
+			'Add to the visible files set with `base`. Paths must be relative to the containing collection `path`.',
+	}),
+	exclude: z.array(z.string()).optional().meta({
+		description:
+			'Remove from the visible files set with `base`. Paths must be relative to the containing collection `path`.',
+	}),
+});
+
+export const FilterSchema = z.union([FilterValueSchema, FilterBaseSchema]).meta({
+	id: 'filter',
+	description:
+		'Controls which files are displayed in the collection list. Does not change which files are assigned to this collection.',
+});
+
+const ParserSchema = z.enum(['csv', 'front-matter', 'json', 'properties', 'toml', 'yaml']).meta({
+	id: 'parser',
+	description:
+		'Overrides the format files are read. Detected automatically from file extension if unset.',
+});
+
+const versionMeta = {
+	description:
+		'Controls which schema this file is validated against. Defaults to the latest schema.',
+};
+
+const collectionsConfigMeta = {
+	title: 'Collections Configuration',
+	description:
+		'Definitions for your collections, which are the sets of content files for your site grouped by folder. Entries are keyed by a chosen collection key, and contain configuration specific to that collection.',
+};
+
+const SingularKeySchema = z.string().meta({
+	id: 'singular_key',
+	description:
+		'Overrides the default singular input key of the collection. This is used for naming conventions for select and multiselect inputs.',
+});
+
+const OutputSchema = z.boolean().meta({
+	id: 'output',
+	description:
+		"Specifies whether this collection's source files build to output files. Defaults to false.",
+});
+
+export const BuildCoupledCollectionConfigSchema = z.object({
+	...CollectionConfigSchema.omit({ url: true, disable_url: true }).shape,
+	path: CollectionConfigSchema.shape.path.optional(),
+	filter: FilterSchema.optional(),
+	singular_key: SingularKeySchema.optional(),
+	output: OutputSchema.optional(),
+});
+
+export const ReaderCollectionConfigSchema = z.object({
+	...CollectionConfigSchema.shape,
+	parser: ParserSchema.optional(),
+	filter: FilterSchema.optional(),
+	singular_key: SingularKeySchema.optional(),
+	output: OutputSchema.optional(),
+});
+
+export const HugoCollectionConfigSchema = z.object({
+	...BuildCoupledCollectionConfigSchema.shape,
+	parse_branch_index: z.boolean().optional().meta({
+		description:
+			'Controls whether branch index files (e.g. `_index.md`) are assigned to this collection or not. The "pages" collection defaults this to true, and false otherwise.',
+	}),
+});
+
+export const BuildCoupledConfigurationSchema = z.object({
+	...ConfigurationSchema.omit({ version: true }).shape,
+	collections_config_override: z.boolean().optional().meta({
+		id: 'collections_config_override',
+		description:
+			'Prevents CloudCannon from automatically discovering collections for supported SSGs if true. Defaults to false.',
+	}),
+	version: z
+		.enum(['legacy-hugo', 'legacy-jekyll', 'legacy-eleventy', 'legacy-reader'])
+		.optional()
+		.meta(versionMeta),
+	paths: BuildCoupledPathsSchema.optional(),
+	collections_config: z
+		.record(z.string(), BuildCoupledCollectionConfigSchema)
+		.optional()
+		.meta({
+			...collectionsConfigMeta,
+			id: 'collections_config:BuildCoupled',
+		}),
+	data_config: z.record(z.string(), z.boolean()).optional().meta({
+		description: 'Controls what data sets are available to populate select and multiselect inputs.',
+	}),
+});
+
+export const ReaderConfigurationSchema = z.object({
+	...BuildCoupledConfigurationSchema.omit({ collections_config_override: true }).shape,
+	version: z.literal('legacy-reader').meta(versionMeta),
+	data_config: z
+		.record(
+			z.string(),
+			z.object({ ...DataConfigEntrySchema.shape, parser: ParserSchema.optional() })
+		)
+		.optional()
+		.meta({
+			description:
+				'Controls what data sets are available to populate select and multiselect inputs.',
+		}),
+	collections_config: z
+		.record(z.string(), ReaderCollectionConfigSchema)
+		.optional()
+		.meta(collectionsConfigMeta),
+	output: z.string().optional().meta({
+		description:
+			'Generates the integration file in another folder. Not applicable to Jekyll, Hugo, and Eleventy. Defaults to the root folder.',
+	}),
+});
+
+export const HugoConfigurationSchema = z.object({
+	...BuildCoupledConfigurationSchema.shape,
+	version: z.literal('legacy-hugo').meta(versionMeta),
+	collections_config: z
+		.record(z.string(), HugoCollectionConfigSchema)
+		.optional()
+		.meta(collectionsConfigMeta),
+});
+
+export const JekyllConfigurationSchema = z.object({
+	...BuildCoupledConfigurationSchema.shape,
+	version: z.literal('legacy-jekyll').meta(versionMeta),
+});
+
+export const EleventyConfigurationSchema = z.object({
+	...BuildCoupledConfigurationSchema.shape,
+	version: z.literal('legacy-eleventy').meta(versionMeta),
+});
+
+export const AnyLegacyConfigurationSchema = z.union([
+	HugoConfigurationSchema,
+	JekyllConfigurationSchema,
+	EleventyConfigurationSchema,
+	ReaderConfigurationSchema,
+]);
+
+export const AnyConfigurationSchema = z.union([ConfigurationSchema, AnyLegacyConfigurationSchema]);
+
+export const ParsedDatasetSchema = z.union([
+	z.array(z.string()),
+	z.record(z.string(), z.string()),
+	z.record(z.string(), z.record(z.string(), z.unknown())),
+	z.array(z.record(z.string(), z.unknown())),
+]);
+
+export const ParsedCollectionItemSchema = z.record(z.string(), z.unknown()).and(
+	z.object({
+		path: z.string().meta({
+			description: 'The path to the file this was parsed from.',
+		}),
+		collection: z.string().optional().meta({
+			description: 'The collection key this is assigned to. Matches keys in `collections_config`.',
+		}),
+		url: z.string().optional().meta({
+			description: 'The URL this file is served at once built.',
+		}),
+	})
+);
+
+const WithIntegrationOutputSchema = z.object({
+	error: z
+		.union([z.literal('NO_CONTENT'), z.string()])
+		.optional()
+		.meta({
+			id: 'error',
+			description:
+				'The error code encountered when attempting to create the integration output file.',
+		}),
+	time: z.string().optional().meta({
+		id: 'time',
+		description: 'The time this file was generated.',
+	}),
+	cloudcannon: z
+		.object({
+			name: z.string().meta({
+				description: 'Name of the integration tool used to generate the integration output file.',
+			}),
+			version: z.string().meta({
+				description:
+					'Version of the integration tool used to generate the integration output file.',
+			}),
+		})
+		.optional()
+		.meta({
+			id: 'cloudcannon',
+			description:
+				'Details about the integration tool used to generate the integration output file.',
+		}),
+	data: z.record(z.string(), ParsedDatasetSchema).optional().meta({
+		id: 'data',
+		description: 'Map of data keys to parsed datasets. Keys match keys in `data_config`.',
+	}),
+	collections: z.record(z.string(), z.array(ParsedCollectionItemSchema)).optional().meta({
+		id: 'collections',
+		description:
+			'Map of collection keys to parsed collection files. Keys match keys in `collections_config`.',
+	}),
+	files: z.record(z.string(), z.string()).optional().meta({
+		id: 'files',
+		description: 'Map of build file paths to MD5s.',
+	}),
+});
+
+export const IntegrationOutputSchema = z.object({
+	...ConfigurationSchema.shape,
+	...WithIntegrationOutputSchema.shape,
+});
+
+export const ReaderIntegrationOutputSchema = z.object({
+	...ReaderConfigurationSchema.shape,
+	...WithIntegrationOutputSchema.shape,
+});
+
+export const HugoIntegrationOutputSchema = z.object({
+	...HugoConfigurationSchema.shape,
+	...WithIntegrationOutputSchema.shape,
+});
+
+export const JekyllIntegrationOutputSchema = z.object({
+	...JekyllConfigurationSchema.shape,
+	...WithIntegrationOutputSchema.shape,
+	defaults: z.unknown(),
+});
+
+export const EleventyIntegrationOutputSchema = z.object({
+	...EleventyConfigurationSchema.shape,
+	...WithIntegrationOutputSchema.shape,
+});
+
+export type BuildCoupledPaths = z.infer<typeof BuildCoupledPathsSchema>;
+export type FilterBase = z.infer<typeof FilterBaseSchema>;
+export type FilterValue = z.infer<typeof FilterValueSchema>;
+export type Filter = z.infer<typeof FilterSchema>;
+export type BuildCoupledCollectionConfig = z.infer<typeof BuildCoupledCollectionConfigSchema>;
+export type ReaderCollectionConfig = z.infer<typeof ReaderCollectionConfigSchema>;
+export type HugoCollectionConfig = z.infer<typeof HugoCollectionConfigSchema>;
+export type BuildCoupledConfiguration = z.infer<typeof BuildCoupledConfigurationSchema>;
+export type ReaderConfiguration = z.infer<typeof ReaderConfigurationSchema>;
+export type HugoConfiguration = z.infer<typeof HugoConfigurationSchema>;
+export type JekyllConfiguration = z.infer<typeof JekyllConfigurationSchema>;
+export type EleventyConfiguration = z.infer<typeof EleventyConfigurationSchema>;
+export type AnyLegacyConfiguration = z.infer<typeof AnyLegacyConfigurationSchema>;
+export type AnyConfiguration = z.infer<typeof AnyConfigurationSchema>;
+export type ParsedDataset = z.infer<typeof ParsedDatasetSchema>;
+export type ParsedCollectionItem = z.infer<typeof ParsedCollectionItemSchema>;
+export type IntegrationOutput = z.infer<typeof IntegrationOutputSchema>;
+export type ReaderIntegrationOutput = z.infer<typeof ReaderIntegrationOutputSchema>;
+export type HugoIntegrationOutput = z.infer<typeof HugoIntegrationOutputSchema>;
+export type JekyllIntegrationOutput = z.infer<typeof JekyllIntegrationOutputSchema>;
+export type EleventyIntegrationOutput = z.infer<typeof EleventyIntegrationOutputSchema>;

package/src/cascade.ts

@@ -0,0 +1,38 @@
+import * as z from 'zod';
+import { EditablesSchema } from './editables';
+import { InputsSchema } from './inputs';
+import { SelectDataSchema } from './select-values';
+import { StructuresSchema } from './structures';
+
+export const EditorKeySchema = z.enum(['visual', 'content', 'data']).meta({
+	id: 'EditorKey',
+	title: 'Editor Key',
+	description: 'The available editors in CloudCannon: visual, content, and data editors.',
+});
+
+export const ReducedCascadeSchema = z.object({
+	_inputs: InputsSchema.optional(),
+	_select_data: SelectDataSchema.optional(),
+	_structures: StructuresSchema.optional(),
+});
+
+export const CascadeSchema = z.object({
+	...ReducedCascadeSchema.shape,
+	_enabled_editors: z.array(EditorKeySchema).optional().meta({
+		id: '_enabled_editors',
+		title: 'Enabled Editors',
+		description:
+			'Set a preferred editor and/or disable the others. The first value sets which editor opens by default, and the following values specify which editors are accessible.',
+		uniqueItems: true,
+	}),
+	_editables: EditablesSchema.optional().meta({
+		id: '_editables',
+		title: 'Editables',
+		description:
+			'Configuration for editable regions in the Visual Editor, including content, block, link, image, and text editing options.',
+	}),
+});
+
+export type EditorKey = z.infer<typeof EditorKeySchema>;
+export type ReducedCascade = z.infer<typeof ReducedCascadeSchema>;
+export type Cascade = z.infer<typeof CascadeSchema>;