@likec4/config 1.46.4 → 1.48.0

package/src/schema.ts

@@ -12,14 +12,23 @@ import type {
 } from '@likec4/core/types'
 import JSON5 from 'json5'
 import type { SimplifyDeep } from 'type-fest'
-import type { URI } from 'vscode-uri'
-import * as z from 'zod'
+import z from 'zod/v4'
 import { ImageAliasesSchema, validateImageAliases } from './schema.image-alias'
 import { IncludeSchema, validateIncludePaths } from './schema.include'
 import { LikeC4StylesConfigSchema } from './schema.theme'
 
+export interface VscodeURI {
+  readonly scheme: string
+  readonly authority: string
+  readonly path: string
+  readonly fsPath: string
+  readonly query: string
+  readonly fragment: string
+  toString(): string
+}
+
 export const ManualLayoutsConfigSchema = z
-  .object({
+  .strictObject({
     outDir: z.string()
       .default('.likec4')
       .meta({
@@ -101,7 +110,7 @@ export type LocateResult = {
   /**
    * Full path to the source file
    */
-  document: URI
+  document: VscodeURI
   /**
    * Document path relative to the project folder
    */
@@ -120,7 +129,7 @@ export interface GeneratorFnContext {
   /**
    * Workspace root directory
    */
-  readonly workspace: URI
+  readonly workspace: VscodeURI
 
   /**
    * Current project
@@ -136,7 +145,7 @@ export interface GeneratorFnContext {
     /**
      * Project folder
      */
-    readonly folder: URI
+    readonly folder: VscodeURI
   }
 
   /**
@@ -158,7 +167,7 @@ export interface GeneratorFnContext {
    * @param content - Content of the file
    */
   write(file: {
-    path: string | string[] | URI
+    path: string | string[] | VscodeURI
     content:
       | string
       | NodeJS.ArrayBufferView

package/dist/shared/config.CUC_rqhf.mjs

@@ -1,376 +0,0 @@
-import JSON5 from 'json5';
-import * as z from 'zod';
-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().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(),
-  // PLAIN key schema - zod 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(" | "));
-  }
-}
-
-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.object({
-  paths: z.array(IncludePathValue).min(1, "Include paths cannot be empty").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).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"
-});
-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) {
-    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)`
-    );
-  }
-}
-
-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.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 arrow = z.literal(RelationshipArrowTypes).meta({ id: "ArrowType" });
-const line = z.literal(["dashed", "solid", "dotted"]).meta({ id: "LineType" });
-const themeColor = z.literal(ThemeColors).meta({ id: "ThemeColor" });
-const color = z.union([
-  themeColor,
-  z.string().min(1, "Color name cannot be empty")
-]).transform((value) => value).meta({ id: "ColorName" });
-const colorValue = 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 colorSchema = colorValue;
-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)").meta({ description: "Label background color" })
-}).meta({ id: "RelationshipColorValues" }).transform((value) => value);
-const ThemeColorValuesSchema = z.union([
-  colorSchema,
-  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: "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.union([
-  z.record(
-    color,
-    ThemeColorValuesSchema
-  ),
-  z.object(
-    t(ThemeColors, () => ThemeColorValuesSchema.optional())
-  )
-]).meta({
-  id: "ThemeColors",
-  description: "Override theme colors"
-});
-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"
-});
-const LikeC4Config_Styles_Theme = z.strictObject({
-  colors: ThemeColorsSchema.optional(),
-  sizes: LikeC4Config_Styles_Theme_Sizes.optional()
-}).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_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"
-});
-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" }),
-  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 LikeC4StylesConfigSchema = z.strictObject({
-  theme: LikeC4Config_Styles_Theme.optional(),
-  defaults: LikeC4Config_Styles_Defaults.optional()
-  // customCss: z
-  //   .array(z.string())
-  //   .meta({ description: 'List of custom CSS files' }),
-}).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 ManualLayoutsConfigSchema = z.object({
-  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",
-  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" }),
-  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(),
-  include: IncludeSchema,
-  styles: LikeC4StylesConfigSchema.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"
-});
-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);
-  }
-  if (parsed.data.include) {
-    validateIncludePaths(parsed.data.include);
-  }
-  return parsed.data;
-}
-
-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, validateIncludePaths as a, isLikeC4JsonConfig as b, isLikeC4NonJsonConfig as c, defineConfig as d, defineGenerators as e, defineStyle as f, defineTheme as g, defineThemeColor as h, isLikeC4Config as i, normalizeIncludeConfig as n, validateProjectConfig as v };

package/src/logger.ts

@@ -1,3 +0,0 @@
-import { rootLogger } from '@likec4/log'
-
-export const logger = rootLogger.getChild('config')