@likec4/config 1.40.0 → 1.42.0

package/dist/index.mjs

@@ -1 +1 @@
-export { C as ConfigFilenames, d as defineConfig, c as defineGenerators, i as isLikeC4Config, a as isLikeC4JsonConfig, b as isLikeC4NonJsonConfig, s as serializableLikeC4ProjectConfig, v as validateProjectConfig } from './shared/config.BgYO9fOn.mjs';
+export { C as ConfigFilenames, d as defineConfig, c as defineGenerators, e as defineStyle, f as defineTheme, g as defineThemeColor, i as isLikeC4Config, a as isLikeC4JsonConfig, b as isLikeC4NonJsonConfig, s as serializableLikeC4ProjectConfig, v as validateProjectConfig } from './shared/config.C9KUVBb7.mjs';

package/dist/node/index.d.mts

@@ -1,8 +1,12 @@
 import { URI } from 'vscode-uri';
 import { LikeC4ProjectConfig } from '../index.mjs';
-export { ConfigFilenames, GeneratorFn, GeneratorFnContext, GeneratorFnParams, LikeC4ProjectJsonConfig, defineConfig, defineGenerators, isLikeC4Config, isLikeC4JsonConfig, isLikeC4NonJsonConfig, serializableLikeC4ProjectConfig, validateProjectConfig } from '../index.mjs';
+export { ConfigFilenames, GeneratorFn, GeneratorFnContext, GeneratorFnParams, LikeC4ProjectConfigInput, LikeC4ProjectJsonConfig, LikeC4StylesConfig, LikeC4StylesConfigInput, defineConfig, defineGenerators, defineStyle, defineTheme, defineThemeColor, isLikeC4Config, isLikeC4JsonConfig, isLikeC4NonJsonConfig, serializableLikeC4ProjectConfig, validateProjectConfig } from '../index.mjs';
+import '@likec4/core';
 import '@likec4/core/model';
 import '@likec4/core/types';
+import 'type-fest';
+import 'zod/v4';
+import '@likec4/core/styles';
 
 /**
  * Load LikeC4 Project config file.

package/dist/node/index.mjs

@@ -2,8 +2,8 @@ import { invariant } from '@likec4/core';
 import { bundleRequire } from 'bundle-require';
 import * as fs from 'node:fs/promises';
 import { dirname } from 'node:path';
-import { a as isLikeC4JsonConfig, v as validateProjectConfig, b as isLikeC4NonJsonConfig, d as defineConfig } from '../shared/config.BgYO9fOn.mjs';
-export { C as ConfigFilenames, c as defineGenerators, i as isLikeC4Config, s as serializableLikeC4ProjectConfig } from '../shared/config.BgYO9fOn.mjs';
+import { a as isLikeC4JsonConfig, v as validateProjectConfig, b as isLikeC4NonJsonConfig, d as defineConfig } from '../shared/config.C9KUVBb7.mjs';
+export { C as ConfigFilenames, c as defineGenerators, e as defineStyle, f as defineTheme, g as defineThemeColor, i as isLikeC4Config, s as serializableLikeC4ProjectConfig } from '../shared/config.C9KUVBb7.mjs';
 import { rootLogger } from '@likec4/log';
 
 const logger = rootLogger.getChild("config");
@@ -34,13 +34,17 @@ async function loadConfig(filepath) {
               path: args.path,
               namespace: "likec4-config"
             }));
-            build.onLoad({ filter: /.*/, namespace: "likec4-config" }, (args) => {
+            build.onLoad({ filter: /.*/, namespace: "likec4-config" }, (_args) => {
               return {
                 contents: `
-function mockDefineConfig(x) { return x }
+// Mock implementation to allow loading config files without bundling @likec4/config
+function mock(x) { return x }
 export {
-  mockDefineConfig as defineConfig,
-  mockDefineConfig as defineGenerators,
+  mock as defineConfig,
+  mock as defineGenerators,
+  mock as defineStyle,
+  mock as defineTheme,
+  mock as defineThemeColor,
 }`,
                 loader: "js"
               };

package/dist/shared/config.C9KUVBb7.mjs

@@ -0,0 +1,307 @@
+import JSON5 from 'json5';
+import * as z from 'zod/v4';
+import z__default from 'zod/v4';
+import { computeColorValues, ElementShapes, Sizes, BorderStyles, RelationshipArrowTypes, ThemeColors } from '@likec4/core/styles';
+import { exact } from '@likec4/core/types';
+
+const IMAGE_ALIAS_KEY_REGEX = /^@[A-Za-z0-9_-]*$/;
+const IMAGE_ALIAS_VALUE_REGEX = /^(?!\/|[A-Za-z]:[\\\/])(?!.*:\/\/).*$/;
+const ImageAliasValue = z.string().nonempty("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(),
+  // PLAIN key schema - valibot JSON schema export-safe.
+  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(" | "));
+  }
+}
+
+function e(e,t,n){let r=n=>e(n,...t);return n===void 0?r:Object.assign(r,{lazy:n,lazyArgs:t})}
+
+function t$1(t,n,r){let i=t.length-n.length;if(i===0)return t(...n);if(i===1)return e(t,n,r);throw Error(`Wrong number of arguments`)}
+
+function t(...t){return t$1(n,t)}function n(e,t){let n={};for(let[r,i]of e.entries())n[i]=t(i,r,e);return n}
+
+const opacity = z__default.number().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__default.literal(ElementShapes).meta({
+  id: "ElementShape",
+  description: "Element shape"
+});
+const border = z__default.literal(BorderStyles).meta({
+  id: "BorderStyle",
+  description: "Border style"
+});
+const size = z__default.literal(Sizes).meta({
+  id: "ElementSize",
+  description: "Element size"
+});
+const arrow = z__default.literal(RelationshipArrowTypes).meta({
+  id: "ArrowType",
+  description: "Relationship arrow type"
+});
+const line = z__default.literal(["dashed", "solid", "dotted"]).meta({
+  id: "LineType",
+  description: "Default line type for relationships"
+});
+const themeColor = z__default.literal(ThemeColors).meta({
+  id: "ThemeColor",
+  description: "Reserved theme color name"
+});
+const color = z__default.union([
+  themeColor,
+  z__default.string().nonempty("Color name cannot be empty")
+]).transform((value) => value).meta({
+  id: "ColorName",
+  description: "Color name (Theme color name or custom color name)"
+});
+const colorValue = z__default.string().nonempty("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 colorSchema = colorValue;
+const ElementColorValuesSchema = z__default.object({
+  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",
+  description: "Specific element colors"
+}).transform((value) => value);
+const RelationshipColorValuesSchema = z__default.object({
+  line: colorSchema.meta({ description: "Line color" }),
+  label: colorSchema.meta({ description: "Label text color" }),
+  labelBg: colorSchema.optional().default("rgba(0, 0, 0, 0)").meta({ description: "Label background color" })
+}).meta({
+  id: "RelationshipColorValues",
+  description: "Specefic relationship colors"
+}).transform((value) => value);
+const ThemeColorValuesSchema = z__default.union([
+  colorSchema,
+  z__default.object({
+    elements: z__default.union([colorSchema, ElementColorValuesSchema]).transform((value) => {
+      if (typeof value === "string") {
+        return computeColorValues(value).elements;
+      }
+      return value;
+    }),
+    relationships: z__default.union([colorSchema, RelationshipColorValuesSchema]).transform((value) => {
+      if (typeof value === "string") {
+        return computeColorValues(value).relationships;
+      }
+      return 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__default.union([
+  z__default.record(
+    color,
+    ThemeColorValuesSchema
+  ),
+  z__default.object(
+    t(ThemeColors, () => ThemeColorValuesSchema.optional())
+  )
+]).meta({
+  id: "ThemeColors",
+  description: "Override of theme colors"
+});
+const DimensionsSchema = z__default.object({
+  width: z__default.number(),
+  height: z__default.number()
+}).meta({
+  id: "Dimensions",
+  description: "Dimensions"
+});
+const LikeC4Config_Styles_Theme = z__default.object({
+  colors: ThemeColorsSchema,
+  sizes: z__default.object(t(Sizes, () => DimensionsSchema.optional())).meta({ description: "Map of theme sizes." })
+}).partial().meta({
+  id: "ThemeCustomization",
+  description: "Theme customization"
+}).transform(({ colors, sizes }) => {
+  return exact({
+    colors: colors ? exact(colors) : void 0,
+    sizes: sizes ? exact(sizes) : void 0
+  });
+});
+const LikeC4Config_Styles_Defaults = z__default.object({
+  color,
+  opacity,
+  border,
+  size,
+  shape,
+  group: z__default.object({
+    color,
+    opacity,
+    border
+  }).partial(),
+  relationship: z__default.object({
+    color,
+    line,
+    arrow
+  }).partial()
+}).partial().meta({
+  id: "DefaultStyleValues",
+  description: "Override default values for style properties\nThese values will be used if such property is not defined"
+});
+const LikeC4StylesConfigSchema = z__default.object({
+  theme: LikeC4Config_Styles_Theme,
+  defaults: LikeC4Config_Styles_Defaults
+  // customCss: z
+  //   .array(z.string())
+  //   .meta({ description: 'List of custom CSS files' }),
+}).partial().meta({
+  id: "StylesConfiguration",
+  description: "Project styles customization"
+}).transform(
+  ({ theme, defaults }) => exact({
+    defaults: normalizeDefaults(defaults),
+    theme
+  })
+);
+function normalizeDefaults(defaults) {
+  if (!defaults) {
+    return void 0;
+  }
+  const { relationship, group, ...rest } = defaults;
+  return exact({
+    ...rest,
+    relationship: relationship && exact(relationship),
+    group: group && exact(group)
+  });
+}
+
+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" }),
+  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" }),
+  imageAliases: ImageAliasesSchema.optional(),
+  styles: LikeC4StylesConfigSchema.optional(),
+  exclude: z.array(z.string()).optional().meta({ description: 'List of file patterns to exclude from the project, default is ["**/node_modules/**"]' })
+}).meta({
+  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(
+    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);
+  }
+  return parsed.data;
+}
+function serializableLikeC4ProjectConfig({
+  generators: _,
+  // omit
+  ...config
+}) {
+  return LikeC4ProjectJsonConfigSchema.parse(config);
+}
+
+const configJsonFilenames = [
+  ".likec4rc",
+  ".likec4.config.json",
+  "likec4.config.json"
+];
+const configNonJsonFilenames = [
+  "likec4.config.js",
+  "likec4.config.mjs",
+  "likec4.config.ts",
+  "likec4.config.mts"
+];
+const ConfigFilenames = [
+  ...configJsonFilenames,
+  ...configNonJsonFilenames
+];
+function isLikeC4JsonConfig(filename) {
+  for (const ext of configJsonFilenames) {
+    if (filename.endsWith(ext)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isLikeC4NonJsonConfig(filename) {
+  for (const ext of configNonJsonFilenames) {
+    if (filename.endsWith(ext)) {
+      return true;
+    }
+  }
+  return false;
+}
+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);
+}
+
+export { ConfigFilenames as C, isLikeC4JsonConfig as a, isLikeC4NonJsonConfig as b, defineGenerators as c, defineConfig as d, defineStyle as e, defineTheme as f, defineThemeColor as g, isLikeC4Config as i, serializableLikeC4ProjectConfig as s, validateProjectConfig as v };

package/node/package.json

@@ -0,0 +1,4 @@
+{
+  "types": "../dist/node/index.d.mts",
+  "module": "../dist/node/index.mjs"
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@likec4/config",
-  "version": "1.40.0",
+  "version": "1.42.0",
   "license": "MIT",
   "homepage": "https://likec4.dev",
   "author": "Denis Davydkov <denis@davydkov.com>",
@@ -15,6 +15,7 @@
     "dist",
     "src",
     "schema.json",
+    "**/package.json",
     "!**/*.spec.ts",
     "!**/*.test-d.ts",
     "!**/__*/*",
@@ -56,40 +57,42 @@
   "dependencies": {
     "bundle-require": "^5.1.0",
     "defu": "^6.1.4",
-    "json5": "^2.2.3"
+    "json5": "^2.2.3",
+    "zod": "^3.25.76",
+    "type-fest": "^4.41.0"
   },
   "peerDependencies": {
     "esbuild": "^0.25.9",
     "vscode-uri": "3.1.0",
-    "@likec4/core": "1.40.0",
-    "@likec4/log": "1.40.0"
+    "@likec4/core": "1.42.0",
+    "@likec4/log": "1.42.0"
   },
   "peerDependenciesMeta": {
-    "@likec4/core": {
-      "optional": true
-    },
     "vscode-uri": {
       "optional": true
     }
   },
   "devDependencies": {
     "@types/node": "~20.19.11",
-    "tsx": "4.20.5",
-    "turbo": "2.5.6",
+    "remeda": "^2.31.1",
+    "tsx": "4.20.6",
+    "turbo": "2.5.8",
     "typescript": "5.9.2",
     "unbuild": "3.5.0",
-    "zod4": "npm:zod@^4.0.17",
+    "nano-spawn": "^1.0.3",
     "vitest": "3.2.4",
-    "@likec4/tsconfig": "1.40.0"
+    "@likec4/core": "1.42.0",
+    "@likec4/log": "1.42.0",
+    "@likec4/devops": "1.41.0",
+    "@likec4/tsconfig": "1.42.0"
   },
   "scripts": {
-    "generate": "tsx scripts/generate.mts",
     "typecheck": "tsc -b --verbose",
     "build": "unbuild",
     "lint:package": "pnpx publint ./package.tgz",
-    "clean": "pnpm rimraf dist lib",
+    "clean": "likec4ops clean",
     "pack": "pnpm pack"
   },
-  "types": "./dist/index.d.mts",
-  "module": "./dist/index.mjs"
+  "types": "dist/index.d.mts",
+  "module": "dist/index.mjs"
 }