@likec4/config 1.47.0 → 1.49.0

package/src/schema.theme.ts

@@ -1,24 +1,29 @@
+// oxlint-disable no-unsafe-type-assertion
+import type {
+  ElementColorValues,
+  RelationshipColorValues,
+  ThemeColorValues,
+} from '@likec4/core/styles'
 import {
-  type ColorLiteral,
-  type ElementColorValues,
-  type RelationshipColorValues,
-  type ThemeColor,
-  type ThemeColorValues,
   BorderStyles,
   computeColorValues,
   ElementShapes,
+  IconPositions,
   RelationshipArrowTypes,
   Sizes,
   ThemeColors,
 } from '@likec4/core/styles'
-import {
-  type LikeC4ProjectStyleDefaults,
-  type LikeC4ProjectStylesConfig,
-  type LikeC4ProjectTheme,
-  exact,
+import type {
+  ColorLiteral,
+  CustomColor,
+  LikeC4ProjectStyleDefaults,
+  LikeC4ProjectStylesConfig,
+  LikeC4ProjectStylesCustomStylesheets,
+  LikeC4ProjectTheme,
+  ThemeColor,
 } from '@likec4/core/types'
-import { fromKeys } from 'remeda'
-import * as z from 'zod'
+import { exact } from '@likec4/core/types'
+import z from 'zod/v4'
 
 const opacity = z
   .int()
@@ -30,44 +35,74 @@ const opacity = z
   })
 
 const shape = z
-  .literal(ElementShapes)
+  .enum(ElementShapes)
   .meta({ id: 'ElementShape' })
 
 const border = z
-  .literal(BorderStyles)
+  .enum(BorderStyles)
   .meta({ id: 'BorderStyle' })
 
 const size = z
-  .literal(Sizes)
+  .enum(Sizes)
   .meta({ id: 'ElementSize' })
 
+const iconPosition = z
+  .enum(IconPositions)
+  .meta({ id: 'IconPosition' })
+
 const arrow = z
-  .literal(RelationshipArrowTypes)
+  .enum(RelationshipArrowTypes)
   .meta({ id: 'ArrowType' })
 
 const line = z
-  .literal(['dashed', 'solid', 'dotted'])
+  .enum(['dashed', 'solid', 'dotted'])
   .meta({ id: 'LineType' })
 
 const themeColor = z
-  .literal(ThemeColors)
-  .meta({ id: 'ThemeColor' })
+  .enum(ThemeColors)
+  .meta({ id: 'ThemeColorName' })
 
-const color = z
-  .union([
-    themeColor,
-    z.string().min(1, 'Color name cannot be empty'),
-  ])
+const customColor = z
+  .custom<string & Record<never, never>>()
+  .refine(v => typeof v === 'string', 'Custom color name must be a string')
+  .transform(value => value as unknown as CustomColor)
+  .meta({ id: 'CustomColorName' })
+
+// const color = z.custom<ColorNameLiteral>(
+//   (v) => {
+//     if (typeof v !== 'string' || v.length === 0) {
+//       throw new Error()
+//     }
+//     return v
+//   },
+//   {
+//     error: 'Invalid color name',
+//   },
+// )
+//   .meta({ id: 'ColorName' })
+
+const color = themeColor.or(customColor)
   .transform(value => value as ThemeColor)
   .meta({ id: 'ColorName' })
+// const color = themeColor.or(
+//   // z.never(),
+//   z.string().spa(),
+// ).meta({ id: 'ColorName' })
+// // .custom<ColorNameLiteral>(v => typeof v === 'string')
+// .union([
+//   themeColor,
+//   customColor,
+// ])
+// .transform(value => value as ThemeColor)
+// .meta({ id: 'ColorName' })
 
 const colorValue = z
   .string()
   .min(1, 'Color value cannot be empty')
-  .transform(value => value as ColorLiteral)
+  // .transform(value => value as ColorLiteral)
   .meta({
     id: 'ColorLiteral',
-    description: 'Color value in any valid CSS format: hex, rgb, rgba, hsl, hsla ...',
+    // description: 'Color value in any valid CSS format: hex, rgb, rgba, hsl, hsla ...',
   })
 
 // const ColorSchema = z.union([ColorValue, LightDarkTuple])
@@ -90,86 +125,71 @@ const RelationshipColorValuesSchema = z
     label: colorSchema.meta({ description: 'Label text color' }),
     labelBg: colorSchema
       .optional()
-      .default('rgba(0, 0, 0, 0)')
+      .default('rgba(0, 0, 0, 0.5)')
       .meta({ description: 'Label background color' }),
   })
   .meta({ id: 'RelationshipColorValues' })
   .transform(value => value as RelationshipColorValues)
 
-export 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): ElementColorValues => {
-          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): RelationshipColorValues => {
-          if (typeof value === 'string') {
-            return computeColorValues(value).relationships
-          }
-          return value
-        }),
+const StrictThemeColorValuesSchema = z.strictObject({
+  elements: ElementColorValuesSchema
+    .or(
+      colorSchema.transform(v => computeColorValues(v as ColorLiteral).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 as ColorLiteral).relationships),
+    )
+    .meta({ description: 'Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values' }),
+})
+  .transform(value => value as ThemeColorValues)
+  .meta({
+    id: 'StrictThemeColorValues',
+    description: 'Exact color value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color value',
+  })
+
+export const ThemeColorValuesSchema = StrictThemeColorValuesSchema.or(
+  colorSchema.transform(v => computeColorValues(v as ColorLiteral)),
+)
+  .transform(value => value as ThemeColorValues)
   .meta({
     id: 'ThemeColorValues',
     description: 'Exact value (hex, rgb, rgba, hsl, hsla ...) or break down of specific color values',
   })
-  .transform((value): ThemeColorValues => {
-    if (typeof value === 'string') {
-      return computeColorValues(value)
-    }
-    return value
-  })
+
 export type ThemeColorValuesInput = z.input<typeof ThemeColorValuesSchema>
 
-const ThemeColorsSchema = z.union([
-  z.record(
-    color,
-    ThemeColorValuesSchema,
-  ),
-  z.object(
-    fromKeys(ThemeColors, () => ThemeColorValuesSchema.optional()),
-  ),
-]).meta({
-  id: 'ThemeColors',
-  description: 'Override theme colors',
-})
+const ThemeColorsSchema = z.partialRecord(
+  color,
+  ThemeColorValuesSchema,
+)
+  .transform(value => value as Record<ThemeColor, ThemeColorValues>)
 
 const DimensionsSchema = z.strictObject({
   width: z.number().min(50),
   height: z.number().min(50),
 }).meta({
   id: 'Dimensions',
-  description: 'Dimensions',
+  description: 'Defines dimensions for theme size',
 })
 
-const LikeC4Config_Styles_Theme_Sizes = z
-  .strictObject(
-    fromKeys(Sizes, () => DimensionsSchema.optional()),
-  )
-  .meta({
-    id: 'ThemeSizes',
-    description: 'Override theme sizes',
-  })
+const LikeC4Config_Styles_Theme_Sizes = z.partialRecord(size, DimensionsSchema)
 
 export 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 }): LikeC4ProjectTheme => {
     return exact({
@@ -189,8 +209,6 @@ const LikeC4Config_Styles_Defaults_Group = z
   })
   .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
@@ -220,32 +238,48 @@ const LikeC4Config_Styles_Defaults = z
     }),
     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' }),
+    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: 'Default style values for relationships',
+      description:
+        'Override default values for relationship style properties\nThese values will be used if such property is not defined',
     }),
   })
   .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',
   })
 
 export 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',
+    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 }): LikeC4ProjectStylesConfig =>
+  .transform(({ theme, defaults, customCss }): LikeC4ProjectStylesConfig =>
     exact({
       defaults: normalizeDefaults(defaults),
+      customCss: normalizeStylesheets(customCss),
       theme,
     })
   )
@@ -262,7 +296,24 @@ function normalizeDefaults(
   const { relationship, group, ...rest } = defaults
   return exact({
     ...rest,
-    relationship: relationship && exact(relationship) as LikeC4ProjectStyleDefaults['relationship'],
-    group: group && exact(group) as LikeC4ProjectStyleDefaults['group'],
-  })
+    relationship: relationship && exact(relationship) satisfies LikeC4ProjectStyleDefaults['relationship'],
+    group: group && exact(group) satisfies LikeC4ProjectStyleDefaults['group'],
+  }) satisfies LikeC4ProjectStyleDefaults
+}
+
+function normalizeStylesheets(
+  stylesheets?: z.infer<typeof LikeC4Config_Styles_CustomStylesheets>,
+): LikeC4ProjectStylesCustomStylesheets | undefined {
+  if (!stylesheets) {
+    return undefined
+  }
+  const paths = (Array.isArray(stylesheets) ? stylesheets : [stylesheets]).filter(Boolean)
+  if (paths.length === 0) {
+    return undefined
+  }
+
+  return {
+    paths,
+    content: '',
+  }
 }

package/src/schema.ts

@@ -11,15 +11,23 @@ import type {
   ProjectId,
 } 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 { ImageAliasesSchema, validateImageAliases } from './schema.image-alias'
-import { IncludeSchema, validateIncludePaths } from './schema.include'
+import z from 'zod/v4'
+import { ImageAliasesSchema } from './schema.image-alias'
+import { type IncludeConfig, IncludeSchema } 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({
@@ -32,7 +40,7 @@ export const ManualLayoutsConfigSchema = z
       }),
   })
   .meta({
-    id: 'manual-layouts-config',
+    id: 'ManualLayoutsConfig',
     description: 'Configuration for manual layouts',
   })
 
@@ -50,6 +58,12 @@ export const LikeC4ProjectJsonConfigSchema = z.object({
       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()
@@ -58,22 +72,22 @@ export const LikeC4ProjectJsonConfigSchema = z.object({
     .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(),
+  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(),
+  manualLayouts: ManualLayoutsConfigSchema.optional(),
 })
   .meta({
-    description: 'LikeC4 project configuration',
+    id: 'LikeC4ProjectConfig',
+    description: 'LikeC4 Project Configuration',
   })
 
-export type LikeC4ProjectJsonConfig = SimplifyDeep<z.input<typeof LikeC4ProjectJsonConfigSchema>>
+export type LikeC4ProjectJsonConfig = z.input<typeof LikeC4ProjectJsonConfigSchema>
 
 const FunctionType = z.instanceof(Function)
 export const GeneratorsSchema = z.record(z.string(), FunctionType)
@@ -101,7 +115,7 @@ export type LocateResult = {
   /**
    * Full path to the source file
    */
-  document: URI
+  document: VscodeURI
   /**
    * Document path relative to the project folder
    */
@@ -120,7 +134,7 @@ export interface GeneratorFnContext {
   /**
    * Workspace root directory
    */
-  readonly workspace: URI
+  readonly workspace: VscodeURI
 
   /**
    * Current project
@@ -136,7 +150,7 @@ export interface GeneratorFnContext {
     /**
      * Project folder
      */
-    readonly folder: URI
+    readonly folder: VscodeURI
   }
 
   /**
@@ -158,7 +172,7 @@ export interface GeneratorFnContext {
    * @param content - Content of the file
    */
   write(file: {
-    path: string | string[] | URI
+    path: string | string[] | VscodeURI
     content:
       | string
       | NodeJS.ArrayBufferView
@@ -227,30 +241,42 @@ export type LikeC4ProjectConfig = z.infer<typeof LikeC4ProjectJsonConfigSchema>
   generators?: Record<string, GeneratorFn> | undefined
 }
 
-export type LikeC4ProjectConfigInput = SimplifyDeep<
-  z.input<typeof LikeC4ProjectJsonConfigSchema> & {
-    generators?: Record<string, GeneratorFn> | undefined
-  }
->
+export type LikeC4ProjectConfigInput = LikeC4ProjectJsonConfig & {
+  generators?: Record<string, GeneratorFn> | undefined
+}
 
 /**
- * Validates JSON string or JSON object into a LikeC4ProjectConfig object.
+ * Validates Object into a LikeC4ProjectConfig object.
  */
-export function validateProjectConfig<C extends string | Record<string, unknown>>(
-  config: C,
-): LikeC4ProjectConfig {
-  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))
-  }
-  // TODO: rewrite with zod refine
-  if (parsed.data.imageAliases) {
-    validateImageAliases(parsed.data.imageAliases)
-  }
-  if (parsed.data.include) {
-    validateIncludePaths(parsed.data.include)
+export function validateProjectConfig<C extends Record<string, unknown>>(config: C): LikeC4ProjectConfig {
+  const parsed = LikeC4ProjectConfigSchema.safeParse(config)
+  if (parsed.success) {
+    return parsed.data as unknown as LikeC4ProjectConfig
   }
-  return parsed.data as unknown as LikeC4ProjectConfig
+  throw new Error('Config validation failed:\n' + z.prettifyError(parsed.error))
+}
+
+/**
+ * Parses JSON string into a LikeC4ProjectConfig object.
+ * Does not process "extends" - use `loadConfig` function instead
+ */
+export function parseProjectConfigJSON(config: string): LikeC4ProjectConfig {
+  const parsed = JSON5.parse(config.trim() || '{}')
+  return validateProjectConfig(parsed)
+}
+
+export const LikeC4ProjectConfigOps = {
+  parse: parseProjectConfigJSON,
+  validate: validateProjectConfig,
+  normalizeInclude: (include: z.input<typeof IncludeSchema> | undefined): IncludeConfig => {
+    const parsed = IncludeSchema.safeParse(include)
+    if (parsed.success) {
+      return parsed.data
+    }
+    return {
+      paths: [],
+      maxDepth: 3,
+      fileThreshold: 30,
+    }
+  },
 }