@likec4/config 1.47.0 → 1.49.0

package/dist/node/index.mjs

@@ -1,42 +1,332 @@
-import { invariant } from '@likec4/core';
-import { bundleRequire } from 'bundle-require';
-import * as fs from 'node:fs/promises';
-import { dirname } from 'node:path';
-import { b as isLikeC4JsonConfig, v as validateProjectConfig, c as isLikeC4NonJsonConfig, d as defineConfig } from '../shared/config.CUC_rqhf.mjs';
-export { C as ConfigFilenames, e as defineGenerators, f as defineStyle, g as defineTheme, h as defineThemeColor, i as isLikeC4Config, n as normalizeIncludeConfig, a as validateIncludePaths } from '../shared/config.CUC_rqhf.mjs';
-import { rootLogger } from '@likec4/log';
-
-const logger = rootLogger.getChild("config");
-
+import { t as defu } from "../_chunks/libs/defu.mjs";
+import { i as t, n as t$1, r as e, t as n } 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";
+import { basename } from "pathe";
+import { invariant } from "@likec4/core";
+import { logger, wrapError } from "@likec4/log";
+import { bundleRequire } from "bundle-require";
+import { formatMessagesSync } from "esbuild";
+import * as fs from "node:fs/promises";
+import { basename as basename$1, dirname, resolve } from "node:path";
+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(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\"]"
+	].join("\n") }),
+	maxDepth: z.number().int().min(1).max(20).default(3).meta({ description: [
+		"Maximum directory depth to scan when searching for .c4 files in include paths.",
+		"Prevents excessive scanning of deeply nested directories.",
+		"Default: 3"
+	].join("\n") }),
+	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 from other directories.", "Example: { \"paths\": [\"../shared\", \"../common/specs\"], \"maxDepth\": 5, \"fileThreshold\": 50 }"].join("\n")
+});
+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.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.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)" }),
+	hiContrast: colorSchema.meta({ description: "High contrast text color (title)" }),
+	loContrast: colorSchema.meta({ description: "Low contrast text color (description)" })
+}).meta({ id: "ElementColorValues" }).transform((value) => value);
+const RelationshipColorValuesSchema = z.strictObject({
+	line: colorSchema.meta({ description: "Line color" }),
+	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 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"
+});
+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: "Defines dimensions for theme size"
+});
+const LikeC4Config_Styles_Theme_Sizes = z.partialRecord(size, DimensionsSchema);
+const LikeC4Config_Styles_Theme = z.strictObject({
+	colors: ThemeColorsSchema.optional().meta({ description: "Override theme colors" }),
+	sizes: LikeC4Config_Styles_Theme_Sizes.optional().meta({ description: "Override theme sizes" })
+}).meta({
+	id: "ThemeCustomization",
+	description: "Customize theme colors and sizes"
+}).transform(({ colors, sizes }) => {
+	return exact({
+		colors: colors ? exact(colors) : void 0,
+		sizes: sizes ? exact(sizes) : void 0
+	});
+});
+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" });
+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" }),
+	arrow: arrow.optional().meta({ description: "Default arrow style for relationships" })
+}).meta({
+	id: "RelationshipDefaultStyleValues",
+	description: "Override default values for relationship style properties\nThese values will be used if such property is not defined"
+});
+const LikeC4Config_Styles_Defaults = z.strictObject({
+	color: color.optional().meta({ description: "Default color for elements\n(must be a valid color name from the theme)" }),
+	opacity: opacity.optional().meta({ description: "Default opacity (0-100%) for elements when displayed as a group (like a container)" }),
+	border: border.optional().meta({ description: "Default border style for elements when displayed as a group (like a container)" }),
+	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: "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().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),
+	theme
+}));
+function normalizeDefaults(defaults) {
+	if (!defaults) return;
+	const { relationship, group, ...rest } = defaults;
+	return exact({
+		...rest,
+		relationship: relationship && exact(relationship),
+		group: group && exact(group)
+	});
+}
+function normalizeStylesheets(stylesheets) {
+	if (!stylesheets) return;
+	const paths = (Array.isArray(stylesheets) ? stylesheets : [stylesheets]).filter(Boolean);
+	if (paths.length === 0) return;
+	return {
+		paths,
+		content: ""
+	};
+}
+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: "ManualLayoutsConfig",
+	description: "Configuration for manual layouts"
+});
+const LikeC4ProjectJsonConfigSchema = z.object({
+	name: z.string().nonempty("Project name cannot be empty").refine((value) => value !== "default", {
+		abort: true,
+		error: "Project name cannot be \"default\""
+	}).refine((value) => !value.includes(".") && !value.includes("@") && !value.includes("#"), {
+		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.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({
+	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() });
+function validateProjectConfig(config) {
+	const parsed = LikeC4ProjectConfigSchema.safeParse(config);
+	if (parsed.success) return parsed.data;
+	throw new Error("Config validation failed:\n" + z.prettifyError(parsed.error));
+}
+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",
+	"likec4.config.json"
+];
+const configNonJsonFilenames = [
+	"likec4.config.js",
+	"likec4.config.cjs",
+	"likec4.config.mjs",
+	"likec4.config.ts",
+	"likec4.config.cts",
+	"likec4.config.mts"
+];
+const ConfigFilenames = [...configJsonFilenames, ...configNonJsonFilenames];
+function isLikeC4JsonConfig(filename) {
+	return configJsonFilenames.includes(basename(filename));
+}
+function isLikeC4NonJsonConfig(filename) {
+	return configNonJsonFilenames.includes(basename(filename));
+}
+function isLikeC4Config(filename) {
+	return isLikeC4JsonConfig(filename) || isLikeC4NonJsonConfig(filename);
+}
+function defineConfig(config) {
+	return LikeC4ProjectConfigSchema.parse(config);
+}
+function defineGenerators(generators) {
+	return GeneratorsSchema.parse(generators);
+}
+function defineThemeColor(colors) {
+	return ThemeColorValuesSchema.parse(colors);
+}
+function defineTheme(theme) {
+	return LikeC4Config_Styles_Theme.parse(theme);
+}
+function defineStyle(styles) {
+	return LikeC4StylesConfigSchema.parse(styles);
+}
+const JsonConfigInputSchema = LikeC4ProjectJsonConfigSchema.pick({
+	extends: true,
+	styles: true
+}).loose();
+const normalizeExtends = (value) => {
+	if (!value) return [];
+	return Array.isArray(value) ? value : [value];
+};
+const parseJsonConfig = async (filepath) => {
+	const content = await fs.readFile(filepath, "utf-8");
+	let parsed;
+	try {
+		parsed = JSON5.parse(content.trim() || "{}");
+	} catch (e) {
+		throw wrapError(e, `${filepath}:`);
+	}
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`${filepath}: Config must be a JSON object`);
+	const result = JsonConfigInputSchema.safeParse(parsed);
+	if (!result.success) throw new Error(`${filepath}: Invalid config\n` + z.prettifyError(result.error));
+	return result.data;
+};
+const loadJsonConfigs = async (filepath, stack) => {
+	if (stack.includes(filepath)) {
+		const cycleStart = stack.indexOf(filepath);
+		const cycle = [...stack.slice(cycleStart), filepath].join(" -> ");
+		throw new Error(`Config extends cycle detected: ${cycle}`);
+	}
+	const parsed = await parseJsonConfig(filepath);
+	const extendsPaths = normalizeExtends(parsed.extends);
+	const nextStack = [...stack, filepath];
+	const configs = [];
+	for (const extendPath of extendsPaths) {
+		const resolvedPath = resolve(dirname(filepath), extendPath);
+		configs.push(...await loadJsonConfigs(resolvedPath, nextStack));
+	}
+	return [...configs, parsed];
+};
 async function loadConfig(filepath) {
-  logger.debug`Loading config file: ${filepath.fsPath}`;
-  if (isLikeC4JsonConfig(filepath.fsPath)) {
-    try {
-      const content = await fs.readFile(filepath.fsPath, "utf-8");
-      return validateProjectConfig(content);
-    } catch (err) {
-      logger.error(`Failed to load json config file: ${filepath.fsPath}`, { err });
-      throw err;
-    }
-  }
-  invariant(isLikeC4NonJsonConfig(filepath.fsPath), `Invalid config file: ${filepath.fsPath}`);
-  try {
-    const cwd = dirname(filepath.fsPath);
-    const { mod } = await bundleRequire({
-      filepath: filepath.fsPath,
-      cwd,
-      esbuildOptions: {
-        resolveExtensions: [".mjs", ".js", ".ts", ".mts"],
-        plugins: [{
-          name: "likec4-config",
-          setup(build) {
-            build.onResolve({ filter: /^@?likec4\/config$/ }, (args) => ({
-              path: args.path,
-              namespace: "likec4-config"
-            }));
-            build.onLoad({ filter: /.*/, namespace: "likec4-config" }, (_args) => {
-              return {
-                contents: `
+	filepath = typeof filepath === "string" ? filepath : filepath.fsPath;
+	logger.getChild("config").debug`Loading config: ${filepath}`;
+	const folder = dirname(filepath);
+	const filename = basename$1(filepath);
+	const implicitcfg = { name: basename$1(folder) };
+	if (isLikeC4JsonConfig(filename)) {
+		const configs = await loadJsonConfigs(resolve(filepath), []);
+		invariant(t(configs, 1), "Expect at least one config");
+		const rootConfig = n(t$1(configs), ["extends", "styles"]);
+		const stylesChain = configs.map((config) => config.styles).filter(e);
+		const mergedStyles = stylesChain.length > 0 ? defu({}, ...stylesChain.reverse()) : void 0;
+		return validateProjectConfig({
+			...implicitcfg,
+			...rootConfig,
+			...mergedStyles ? { styles: mergedStyles } : {}
+		});
+	}
+	invariant(isLikeC4NonJsonConfig(filename), `Invalid name for config file: ${filepath}`);
+	const { mod } = await bundleRequire({
+		filepath,
+		cwd: folder,
+		esbuildOptions: {
+			resolveExtensions: [
+				".ts",
+				".mts",
+				".cts",
+				".mjs",
+				".js",
+				".cjs"
+			],
+			plugins: [{
+				name: "likec4-config",
+				setup(build) {
+					build.onResolve({ filter: /^@?likec4\/config$/ }, (args) => ({
+						path: args.path,
+						namespace: "likec4-config"
+					}));
+					build.onEnd((result) => {
+						const messages = formatMessagesSync(result.errors, { kind: "error" });
+						for (const message of messages) logger.error(message);
+					});
+					build.onLoad({
+						filter: /.*/,
+						namespace: "likec4-config"
+					}, (_args) => {
+						return {
+							contents: `
 // Mock implementation to allow loading config files without bundling @likec4/config
 function mock(x) { return x }
 export {
@@ -46,18 +336,13 @@ export {
   mock as defineTheme,
   mock as defineThemeColor,
 }`,
-                loader: "js"
-              };
-            });
-          }
-        }]
-      }
-    });
-    return defineConfig(mod?.default ?? mod);
-  } catch (err) {
-    logger.error(`Failed to load config file: ${filepath.fsPath}`, { err });
-    throw err;
-  }
-}
-
-export { defineConfig, isLikeC4JsonConfig, isLikeC4NonJsonConfig, loadConfig, validateProjectConfig };
+							loader: "js"
+						};
+					});
+				}
+			}]
+		}
+	});
+	return validateProjectConfig(Object.assign(implicitcfg, mod?.default ?? mod));
+}
+export { ConfigFilenames, LikeC4ProjectConfigOps, defineConfig, defineGenerators, defineStyle, defineTheme, defineThemeColor, isLikeC4Config, isLikeC4JsonConfig, isLikeC4NonJsonConfig, loadConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/config",
-  "version": "1.47.0",
+  "version": "1.49.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -25,6 +25,7 @@
   "sideEffects": false,
   "exports": {
     ".": {
+      "sources": "./src/index.ts",
       "node": {
         "sources": "./src/node/index.ts",
         "default": {
@@ -32,7 +33,6 @@
           "default": "./dist/node/index.mjs"
         }
       },
-      "sources": "./src/index.ts",
       "default": {
         "types": "./dist/index.d.mts",
         "default": "./dist/index.mjs"
@@ -45,8 +45,6 @@
         "default": "./dist/node/index.mjs"
       }
     },
-    "./src": "./src/index.ts",
-    "./src/*": "./src/*",
     "./package.json": "./package.json",
     "./schema.json": "./schema.json"
   },
@@ -55,40 +53,43 @@
     "access": "public"
   },
   "dependencies": {
-    "bundle-require": "^5.1.0",
-    "defu": "^6.1.4",
     "json5": "^2.2.3",
-    "zod": "^4.2.1",
-    "type-fest": "^4.41.0"
+    "pathe": "^2.0.3",
+    "zod": "^3.25.76",
+    "type-fest": "^4.41.0",
+    "@likec4/log": "1.49.0",
+    "@likec4/core": "1.49.0"
   },
   "peerDependencies": {
-    "esbuild": "^0.27.2",
-    "vscode-uri": "3.1.0",
-    "@likec4/core": "1.47.0",
-    "@likec4/log": "1.46.1"
+    "bundle-require": "^5.1.0",
+    "esbuild": "0.27.3"
   },
   "peerDependenciesMeta": {
-    "vscode-uri": {
+    "esbuild": {
+      "optional": true
+    },
+    "bundle-require": {
       "optional": true
     }
   },
   "devDependencies": {
-    "@types/node": "~22.19.3",
-    "remeda": "^2.32.0",
+    "@types/node": "~22.19.10",
+    "remeda": "^2.33.5",
+    "defu": "^6.1.4",
+    "ufo": "1.6.3",
     "tsx": "4.21.0",
-    "turbo": "2.7.2",
+    "turbo": "2.8.3",
     "typescript": "5.9.3",
-    "unbuild": "3.5.0",
+    "obuild": "^0.4.27",
     "nano-spawn": "^2.0.0",
-    "vitest": "4.0.16",
-    "@likec4/core": "1.47.0",
-    "@likec4/tsconfig": "1.46.1",
+    "vitest": "4.0.18",
     "@likec4/devops": "1.42.0",
-    "@likec4/log": "1.46.1"
+    "@likec4/tsconfig": "1.49.0"
   },
   "scripts": {
+    "generate": "tsx --conditions=sources scripts/generate.mts",
     "typecheck": "tsc -b --verbose",
-    "build": "unbuild",
+    "build": "obuild",
     "lint:package": "pnpx publint ./package.tgz",
     "clean": "likec4ops clean",
     "pack": "pnpm pack"