@likec4/config 1.48.0 → 1.49.0

package/dist/index.mjs

@@ -1,35 +1,19 @@
-import { t } from "./_chunks/libs/remeda.mjs";
 import JSON5 from "json5";
 import z from "zod/v4";
 import { BorderStyles, ElementShapes, IconPositions, RelationshipArrowTypes, Sizes, ThemeColors, computeColorValues } from "@likec4/core/styles";
 import { exact } from "@likec4/core/types";
-
-//#region src/schema.image-alias.ts
+import { basename } from "pathe";
 const IMAGE_ALIAS_KEY_REGEX = /^@[A-Za-z0-9_-]*$/;
 const IMAGE_ALIAS_VALUE_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/;
+const ImageAliasKey = z.string().min(1, "Image alias key cannot be empty").regex(IMAGE_ALIAS_KEY_REGEX, "Image alias key must match /^@\\w+$/");
 const ImageAliasValue = z.string().min(1, "Image alias value cannot be empty").regex(IMAGE_ALIAS_VALUE_REGEX, "Image alias value must be a relative path (no leading slash or protocol)");
-const ImageAliasesSchema = z.record(z.string(), ImageAliasValue).meta({ description: "Map of image alias prefixes to relative paths (keys must match /^@\\w+$/; values must be relative paths without protocol or leading slash)." });
-function validateImageAliases(imageAliases) {
-	const invalidKeys = [];
-	const invalidValues = [];
-	if (imageAliases) for (const [key, value] of Object.entries(imageAliases)) {
-		if (!IMAGE_ALIAS_KEY_REGEX.test(key)) invalidKeys.push(key);
-		if (!IMAGE_ALIAS_VALUE_REGEX.test(value)) invalidValues.push(`${key} -> ${value}`);
-	}
-	if (invalidKeys.length || invalidValues.length) {
-		const parts = [];
-		if (invalidKeys.length) parts.push(`Invalid image alias key(s): ${invalidKeys.map((k) => JSON.stringify(k)).join(", ")} (must match ${IMAGE_ALIAS_KEY_REGEX})`);
-		if (invalidValues.length) parts.push(`Invalid image alias value(s): ${invalidValues.map((kv) => JSON.stringify(kv)).join(", ")} (must match ${IMAGE_ALIAS_VALUE_REGEX})`);
-		throw new Error(parts.join(" | "));
-	}
-}
-
-//#endregion
-//#region src/schema.include.ts
-const RELATIVE_PATH_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/;
-const IncludePathValue = z.string().min(1, "Include path cannot be empty").regex(RELATIVE_PATH_REGEX, "Include path must be a relative path (no leading slash, drive letter, or protocol)");
-const IncludeConfigSchema = z.strictObject({
-	paths: z.array(IncludePathValue).min(1, "Include paths cannot be empty").meta({ description: [
+const ImageAliasesSchema = z.record(ImageAliasKey, ImageAliasValue).meta({
+	id: "ImageAliases",
+	description: "Map of image alias prefixes to relative paths (keys must match /^@\\w+$/; values must be relative paths without protocol or leading slash)."
+});
+const IncludePathValue = z.string().min(1, "Include path cannot be empty").regex(/^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/, "Include path must be a relative path (no leading slash, drive letter, or protocol)");
+const IncludeSchema = z.strictObject({
+	paths: z.array(IncludePathValue).meta({ description: [
 		"Additional relative directory paths to include LikeC4 source files from, searched recursively.",
 		"Paths are relative to the project folder (the folder containing this config file).",
 		"Example: [\"../shared\", \"../common/specs\"]"
@@ -39,54 +23,33 @@ const IncludeConfigSchema = z.strictObject({
 		"Prevents excessive scanning of deeply nested directories.",
 		"Default: 3"
 	].join("\n") }),
-	fileThreshold: z.number().int().min(1).default(30).meta({ description: [
+	fileThreshold: z.number().int().min(1).max(1e4).default(30).meta({ description: [
 		"Maximum number of files to load from include paths before warning.",
 		"Helps identify performance issues from accidentally including large directories.",
 		"Default: 30"
 	].join("\n") })
 }).meta({
 	id: "include-config",
-	description: "Configuration for including additional LikeC4 source files"
+	description: ["Configuration for including additional LikeC4 source files from other directories.", "Example: { \"paths\": [\"../shared\", \"../common/specs\"], \"maxDepth\": 5, \"fileThreshold\": 50 }"].join("\n")
 });
-const IncludeSchema = IncludeConfigSchema.optional().meta({ description: ["Configuration for including additional LikeC4 source files from other directories.", "Example: { \"paths\": [\"../shared\", \"../common/specs\"], \"maxDepth\": 5, \"fileThreshold\": 50 }"].join("\n") });
-function normalizeIncludeConfig(include) {
-	if (!include) return {
-		paths: [],
-		maxDepth: 3,
-		fileThreshold: 30
-	};
-	return include;
-}
-function validateIncludePaths(include) {
-	if (!include?.paths) return;
-	const invalidPaths = [];
-	for (const path of include.paths) if (!RELATIVE_PATH_REGEX.test(path)) invalidPaths.push(path);
-	if (invalidPaths.length > 0) throw new Error(`Invalid include path(s): ${invalidPaths.map((p) => JSON.stringify(p)).join(", ")} (must be relative paths without leading slash, drive letter, or protocol)`);
-}
-
-//#endregion
-//#region src/schema.theme.ts
 const opacity = z.int().min(0, "Opacity must be between 0 and 100").max(100, "Opacity must be between 0 and 100").meta({
 	id: "Opacity",
 	description: "Opacity 0-100%"
 });
-const shape = z.literal(ElementShapes).meta({ id: "ElementShape" });
-const border = z.literal(BorderStyles).meta({ id: "BorderStyle" });
-const size = z.literal(Sizes).meta({ id: "ElementSize" });
-const iconPosition = z.literal(IconPositions).meta({ id: "IconPosition" });
-const arrow = z.literal(RelationshipArrowTypes).meta({ id: "ArrowType" });
-const line = z.literal([
+const shape = z.enum(ElementShapes).meta({ id: "ElementShape" });
+const border = z.enum(BorderStyles).meta({ id: "BorderStyle" });
+const size = z.enum(Sizes).meta({ id: "ElementSize" });
+const iconPosition = z.enum(IconPositions).meta({ id: "IconPosition" });
+const arrow = z.enum(RelationshipArrowTypes).meta({ id: "ArrowType" });
+const line = z.enum([
 	"dashed",
 	"solid",
 	"dotted"
 ]).meta({ id: "LineType" });
-const themeColor = z.literal(ThemeColors).meta({ id: "ThemeColor" });
-const customColor = z.string().min(1, "Custom color name cannot be empty").transform((value) => value).meta({ id: "CustomColorName" });
-const color = z.union([themeColor, customColor]).transform((value) => value).meta({ id: "ColorName" });
-const colorSchema = z.string().min(1, "Color value cannot be empty").transform((value) => value).meta({
-	id: "ColorLiteral",
-	description: "Color value in any valid CSS format: hex, rgb, rgba, hsl, hsla ..."
-});
+const themeColor = z.enum(ThemeColors).meta({ id: "ThemeColorName" });
+const customColor = z.custom().refine((v) => typeof v === "string", "Custom color name must be a string").transform((value) => value).meta({ id: "CustomColorName" });
+const color = themeColor.or(customColor).transform((value) => value).meta({ id: "ColorName" });
+const colorSchema = z.string().min(1, "Color value cannot be empty").meta({ id: "ColorLiteral" });
 const ElementColorValuesSchema = z.strictObject({
 	fill: colorSchema.meta({ description: "Background color" }),
 	stroke: colorSchema.meta({ description: "Stroke color (border, paths above background)" }),
@@ -98,44 +61,31 @@ const RelationshipColorValuesSchema = z.strictObject({
 	label: colorSchema.meta({ description: "Label text color" }),
 	labelBg: colorSchema.optional().default("rgba(0, 0, 0, 0.5)").meta({ description: "Label background color" })
 }).meta({ id: "RelationshipColorValues" }).transform((value) => value);
-const StrictThemeColorValuesSchema = z.strictObject({
-	elements: z.union([colorSchema, ElementColorValuesSchema]).meta({ description: "Element color value (or a breakdown of specific color values)" }).transform((value) => {
-		if (typeof value === "string") return computeColorValues(value).elements;
-		return value;
-	}),
-	relationships: z.union([colorSchema, RelationshipColorValuesSchema]).meta({ description: "Relationship color value (or a breakdown of specific color values)" }).transform((value) => {
-		if (typeof value === "string") return computeColorValues(value).relationships;
-		return value;
-	})
-}).meta({ id: "StrictThemeColorValues" });
-const ThemeColorValuesSchema = z.union([colorSchema, StrictThemeColorValuesSchema]).meta({
+const ThemeColorValuesSchema = z.strictObject({
+	elements: ElementColorValuesSchema.or(colorSchema.transform((v) => computeColorValues(v).elements)).meta({ description: "Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values" }),
+	relationships: RelationshipColorValuesSchema.or(colorSchema.transform((v) => computeColorValues(v).relationships)).meta({ description: "Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values" })
+}).transform((value) => value).meta({
+	id: "StrictThemeColorValues",
+	description: "Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color value"
+}).or(colorSchema.transform((v) => computeColorValues(v))).transform((value) => value).meta({
 	id: "ThemeColorValues",
 	description: "Exact value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values"
-}).transform((value) => {
-	if (typeof value === "string") return computeColorValues(value);
-	return value;
 });
-const ThemeColorsSchema = z.record(color, ThemeColorValuesSchema).meta({
-	id: "ThemeColors",
-	description: "Override theme colors"
-}).transform((value) => value);
+const ThemeColorsSchema = z.partialRecord(color, ThemeColorValuesSchema).transform((value) => value);
 const DimensionsSchema = z.strictObject({
 	width: z.number().min(50),
 	height: z.number().min(50)
 }).meta({
 	id: "Dimensions",
-	description: "Dimensions"
-});
-const LikeC4Config_Styles_Theme_Sizes = z.strictObject(t(Sizes, () => DimensionsSchema.optional())).meta({
-	id: "ThemeSizes",
-	description: "Override theme sizes"
+	description: "Defines dimensions for theme size"
 });
+const LikeC4Config_Styles_Theme_Sizes = z.partialRecord(size, DimensionsSchema);
 const LikeC4Config_Styles_Theme = z.strictObject({
-	colors: ThemeColorsSchema.optional(),
-	sizes: LikeC4Config_Styles_Theme_Sizes.optional()
+	colors: ThemeColorsSchema.optional().meta({ description: "Override theme colors" }),
+	sizes: LikeC4Config_Styles_Theme_Sizes.optional().meta({ description: "Override theme sizes" })
 }).meta({
 	id: "ThemeCustomization",
-	description: "Theme customization"
+	description: "Customize theme colors and sizes"
 }).transform(({ colors, sizes }) => {
 	return exact({
 		colors: colors ? exact(colors) : void 0,
@@ -146,10 +96,7 @@ const LikeC4Config_Styles_Defaults_Group = z.strictObject({
 	color: color.optional().meta({ description: "Default color for groups\n(must be a valid color name from the theme)" }),
 	opacity: opacity.optional().meta({ description: "Default opacity for groups" }),
 	border: border.optional().meta({ description: "Default border for groups" })
-}).meta({
-	id: "GroupDefaultStyleValues",
-	description: "Override default values for group style properties\nThese values will be used if such property is not defined"
-});
+}).meta({ id: "GroupDefaultStyleValues" });
 const LikeC4Config_Styles_Defaults_Relationship = z.strictObject({
 	color: color.optional().meta({ description: "Default color for relationships\n(must be a valid color name from the theme)" }),
 	line: line.optional().meta({ description: "Default line style for relationships" }),
@@ -165,23 +112,14 @@ const LikeC4Config_Styles_Defaults = z.strictObject({
 	size: size.optional().meta({ description: "Default size for elements" }),
 	shape: shape.optional().meta({ description: "Default shape for elements" }),
 	iconPosition: iconPosition.optional().meta({ description: "Default icon position for elements" }),
-	group: LikeC4Config_Styles_Defaults_Group.optional().meta({ description: "Default style values for groups" }),
-	relationship: LikeC4Config_Styles_Defaults_Relationship.optional().meta({ description: "Default style values for relationships" })
-}).meta({
-	id: "DefaultStyleValues",
-	description: "Override default values for style properties\nThese values will be used if such property is not defined"
-});
-const LikeC4Config_Styles_CustomStylesheets = z.union([z.string().min(1, "Custom CSS file path cannot be empty"), z.array(z.string().min(1, "Custom CSS file path cannot be empty"))]).meta({
-	id: "CustomStylesheets",
-	description: "Custom CSS (or list of CSS files) to be included in the generated diagrams"
-});
+	group: LikeC4Config_Styles_Defaults_Group.optional().meta({ description: "Override default values for group style properties\nThese values will be used if such property is not defined" }),
+	relationship: LikeC4Config_Styles_Defaults_Relationship.optional().meta({ description: "Override default values for relationship style properties\nThese values will be used if such property is not defined" })
+}).meta({ id: "DefaultStyleValues" });
+const LikeC4Config_Styles_CustomStylesheets = z.union([z.string().min(1, "Custom CSS file path cannot be empty"), z.array(z.string().min(1, "Custom CSS file path cannot be empty"))]).meta({ id: "CustomStylesheets" });
 const LikeC4StylesConfigSchema = z.strictObject({
-	theme: LikeC4Config_Styles_Theme.optional(),
-	defaults: LikeC4Config_Styles_Defaults.optional(),
-	customCss: LikeC4Config_Styles_CustomStylesheets.optional()
-}).meta({
-	id: "StylesConfiguration",
-	description: "Project styles customization"
+	theme: LikeC4Config_Styles_Theme.optional().meta({ description: "Project theme customization" }),
+	defaults: LikeC4Config_Styles_Defaults.optional().meta({ description: "Override default values for style properties\nThese values will be used if such property is not defined" }),
+	customCss: LikeC4Config_Styles_CustomStylesheets.optional().meta({ description: "Custom CSS (or list of CSS files) to be included in the generated diagrams" })
 }).transform(({ theme, defaults, customCss }) => exact({
 	defaults: normalizeDefaults(defaults),
 	customCss: normalizeStylesheets(customCss),
@@ -205,16 +143,13 @@ function normalizeStylesheets(stylesheets) {
 		content: ""
 	};
 }
-
-//#endregion
-//#region src/schema.ts
 const ManualLayoutsConfigSchema = z.strictObject({ outDir: z.string().default(".likec4").meta({ description: [
 	"Path to the directory where manual layouts will be stored,",
 	"relative to the folder containing the project config. ",
 	"",
 	"Defaults to '.likec4'."
 ].join("\n") }) }).meta({
-	id: "manual-layouts-config",
+	id: "ManualLayoutsConfig",
 	description: "Configuration for manual layouts"
 });
 const LikeC4ProjectJsonConfigSchema = z.object({
@@ -225,30 +160,42 @@ const LikeC4ProjectJsonConfigSchema = z.object({
 		abort: true,
 		error: "Project name cannot contain \".\", \"@\" or \"#\", try to use A-z, 0-9, _ and -"
 	}).meta({ description: "Project name, must be unique in the workspace" }),
+	extends: z.union([z.string().min(1, "Extend path cannot be empty"), z.array(z.string().min(1, "Extend path cannot be empty")).min(1, "Extend list cannot be empty")]).optional().meta({ description: "Extend styles from other config files" }),
 	title: z.string().nonempty("Project title cannot be empty if specified").optional().meta({ description: "A human readable title for the project" }),
 	contactPerson: z.string().nonempty("Contact person cannot be empty if specified").optional().meta({ description: "A person who has been involved in creating or maintaining this project" }),
+	styles: LikeC4StylesConfigSchema.optional().meta({ description: "Project styles customization" }),
 	imageAliases: ImageAliasesSchema.optional(),
-	include: IncludeSchema,
-	styles: LikeC4StylesConfigSchema.optional(),
+	include: IncludeSchema.optional(),
 	exclude: z.array(z.string()).optional().meta({ description: "List of file patterns to exclude from the project, default is [\"**/node_modules/**\"]" }),
 	manualLayouts: ManualLayoutsConfigSchema.optional()
-}).meta({ description: "LikeC4 project configuration" });
+}).meta({
+	id: "LikeC4ProjectConfig",
+	description: "LikeC4 Project Configuration"
+});
 const FunctionType = z.instanceof(Function);
 const GeneratorsSchema = z.record(z.string(), FunctionType);
 const LikeC4ProjectConfigSchema = LikeC4ProjectJsonConfigSchema.extend({ generators: GeneratorsSchema.optional() });
-/**
-* Validates JSON string or JSON object into a LikeC4ProjectConfig object.
-*/
 function validateProjectConfig(config) {
-	const parsed = LikeC4ProjectConfigSchema.safeParse(typeof config === "string" ? JSON5.parse(config) : config);
-	if (!parsed.success) throw new Error("Config validation failed:\n" + z.prettifyError(parsed.error));
-	if (parsed.data.imageAliases) validateImageAliases(parsed.data.imageAliases);
-	if (parsed.data.include) validateIncludePaths(parsed.data.include);
-	return parsed.data;
+	const parsed = LikeC4ProjectConfigSchema.safeParse(config);
+	if (parsed.success) return parsed.data;
+	throw new Error("Config validation failed:\n" + z.prettifyError(parsed.error));
 }
-
-//#endregion
-//#region src/filenames.ts
+function parseProjectConfigJSON(config) {
+	return validateProjectConfig(JSON5.parse(config.trim() || "{}"));
+}
+const LikeC4ProjectConfigOps = {
+	parse: parseProjectConfigJSON,
+	validate: validateProjectConfig,
+	normalizeInclude: (include) => {
+		const parsed = IncludeSchema.safeParse(include);
+		if (parsed.success) return parsed.data;
+		return {
+			paths: [],
+			maxDepth: 3,
+			fileThreshold: 30
+		};
+	}
+};
 const configJsonFilenames = [
 	".likec4rc",
 	".likec4.config.json",
@@ -263,145 +210,28 @@ const configNonJsonFilenames = [
 	"likec4.config.mts"
 ];
 const ConfigFilenames = [...configJsonFilenames, ...configNonJsonFilenames];
-/**
-* Checks if the given filename is a LikeC4 JSON config file (JSON, RC).
-*/
 function isLikeC4JsonConfig(filename) {
-	for (const ext of configJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
+	return configJsonFilenames.includes(basename(filename));
 }
-/**
-* Checks if the given filename is a LikeC4 non-JSON config file (JS, MJS, TS, MTS)
-*/
 function isLikeC4NonJsonConfig(filename) {
-	for (const ext of configNonJsonFilenames) if (filename.endsWith(ext)) return true;
-	return false;
+	return configNonJsonFilenames.includes(basename(filename));
 }
-/**
-* Checks if the given filename is a LikeC4 config file (JSON or non-JSON)
-*/
 function isLikeC4Config(filename) {
 	return isLikeC4JsonConfig(filename) || isLikeC4NonJsonConfig(filename);
 }
-
-//#endregion
-//#region src/define-config.ts
-/**
-* Defines LikeC4 Project, allows custom generators that can be executed using CLI:
-*
-* `$ likec4 gen <generator-name>`
-*
-* or VSCode command `LikeC4: Run code generator`
-*
-* @example
-* ```ts
-* export default defineConfig({
-*   name: 'my-project',
-*   title: 'My Project',
-*
-*   exclude: ['picomatch pattern'],
-*   generators: {
-*     '<generator-name>': async ({ likec4model, ctx }) => {
-*       await ctx.write('my-generator.txt', likec4model.project.id)
-*     }
-*   }
-* })
-* ```
-*/
 function defineConfig(config) {
 	return LikeC4ProjectConfigSchema.parse(config);
 }
-/**
-* Define reusable custom generators
-*
-* @example
-* ```ts
-* // generators.ts
-* export default defineGenerators({
-*   'my-generator': async ({ likec4model, ctx }) => {
-*     await ctx.write('my-generator.txt', likec4model.project.id)
-*   }
-* })
-*
-* // likec4.config.ts
-* import generators from './generators'
-*
-* export default defineConfig({
-*   name: 'my-project',
-*   generators,
-* })
-* ```
-*/
 function defineGenerators(generators) {
 	return GeneratorsSchema.parse(generators);
 }
-/**
-* Define reusable custom theme color
-* @example
-* ```ts
-* export default defineThemeColor({
-*   element: {
-*     fill: 'red'
-*   }
-* })
-* ```
-*/
 function defineThemeColor(colors) {
 	return ThemeColorValuesSchema.parse(colors);
 }
-/**
-* Define reusable custom theme
-* @example
-* ```ts
-* import { defineThemeColor, defineTheme } from 'likec4/config'
-*
-* export default defineTheme({
-*   colors: {
-*     primary: '#FF0000',
-*     // Or use defineThemeColor
-*     red: defineThemeColor({
-*       elements: {
-*         fill: 'red'
-*       }
-*     })
-*   }
-* })
-* ```
-*/
 function defineTheme(theme) {
 	return LikeC4Config_Styles_Theme.parse(theme);
 }
-/**
-* Define reusable custom style
-* @example
-* ```ts
-* import { defineStyle, defineThemeColor } from 'likec4/config'
-*
-* export default defineStyle({
-*   theme: {
-*     colors: {
-*       red: defineThemeColor({
-*         elements: {
-*           fill: 'red'
-*         }
-*       })
-*     }
-*   },
-*   defaults: {
-*     color: 'red',
-*     opacity: 50,
-*     border: 'solid',
-*     size: 'sm',
-*     relationship: {
-*       color: 'grey',
-*       line: 'solid',
-*     }
-*   }
-* })
-*/
 function defineStyle(styles) {
 	return LikeC4StylesConfigSchema.parse(styles);
 }
-
-//#endregion
-export { ConfigFilenames, defineConfig, defineGenerators, defineStyle, defineTheme, defineThemeColor, isLikeC4Config, isLikeC4JsonConfig, isLikeC4NonJsonConfig, normalizeIncludeConfig, validateIncludePaths, validateProjectConfig };
+export { ConfigFilenames, LikeC4ProjectConfigOps, defineConfig, defineGenerators, defineStyle, defineTheme, defineThemeColor, isLikeC4Config, isLikeC4JsonConfig, isLikeC4NonJsonConfig };