@likec4/config 1.42.1 → 1.44.0

package/src/schema.theme.ts

@@ -18,57 +18,48 @@ import {
   exact,
 } from '@likec4/core/types'
 import { fromKeys } from 'remeda'
-import z from 'zod/v4'
+import * as z from 'zod'
 
 const opacity = z
-  .number()
+  .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%',
+    description: 'Opacity 0-100%',
   })
 
-const shape = z.literal(ElementShapes).meta({
-  id: 'ElementShape',
-  description: 'Element shape',
-})
+const shape = z
+  .literal(ElementShapes)
+  .meta({ id: 'ElementShape' })
 
-const border = z.literal(BorderStyles).meta({
-  id: 'BorderStyle',
-  description: 'Border style',
-})
+const border = z
+  .literal(BorderStyles)
+  .meta({ id: 'BorderStyle' })
 
-const size = z.literal(Sizes).meta({
-  id: 'ElementSize',
-  description: 'Element size',
-})
+const size = z
+  .literal(Sizes)
+  .meta({ id: 'ElementSize' })
+
+const arrow = z
+  .literal(RelationshipArrowTypes)
+  .meta({ id: 'ArrowType' })
 
-const arrow = z.literal(RelationshipArrowTypes).meta({
-  id: 'ArrowType',
-  description: 'Relationship arrow type',
-})
 const line = z
   .literal(['dashed', 'solid', 'dotted'])
-  .meta({
-    id: 'LineType',
-    description: 'Default line type for relationships',
-  })
+  .meta({ id: 'LineType' })
 
-const themeColor = z.literal(ThemeColors).meta({
-  id: 'ThemeColor',
-  description: 'Reserved theme color name',
-})
+const themeColor = z
+  .literal(ThemeColors)
+  .meta({ id: 'ThemeColor' })
 
-const color = z.union([
-  themeColor,
-  z.string().nonempty('Color name cannot be empty'),
-])
+const color = z
+  .union([
+    themeColor,
+    z.string().nonempty('Color name cannot be empty'),
+  ])
   .transform(value => value as ThemeColor)
-  .meta({
-    id: 'ColorName',
-    description: 'Color name (Theme color name or custom color name)',
-  })
+  .meta({ id: 'ColorName' })
 
 const colorValue = z
   .string()
@@ -84,20 +75,17 @@ const colorSchema = colorValue
 // type ColorValue = z.infer<typeof colorSchema>
 
 const ElementColorValuesSchema = z
-  .object({
+  .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',
-    description: 'Specific element colors',
-  })
+  .meta({ id: 'ElementColorValues' })
   .transform(value => value as ElementColorValues)
 
 const RelationshipColorValuesSchema = z
-  .object({
+  .strictObject({
     line: colorSchema.meta({ description: 'Line color' }),
     label: colorSchema.meta({ description: 'Label text color' }),
     labelBg: colorSchema
@@ -105,18 +93,16 @@ const RelationshipColorValuesSchema = z
       .default('rgba(0, 0, 0, 0)')
       .meta({ description: 'Label background color' }),
   })
-  .meta({
-    id: 'RelationshipColorValues',
-    description: 'Specefic relationship colors',
-  })
+  .meta({ id: 'RelationshipColorValues' })
   .transform(value => value as RelationshipColorValues)
 
 export const ThemeColorValuesSchema = z
   .union([
     colorSchema,
-    z.object({
+    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
@@ -125,6 +111,7 @@ export const ThemeColorValuesSchema = z
         }),
       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
@@ -155,25 +142,31 @@ const ThemeColorsSchema = z.union([
   ),
 ]).meta({
   id: 'ThemeColors',
-  description: 'Override of theme colors',
+  description: 'Override theme colors',
 })
 
-const DimensionsSchema = z.object({
-  width: z.number(),
-  height: z.number(),
+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(
+    fromKeys(Sizes, () => DimensionsSchema.optional()),
+  )
+  .meta({
+    id: 'ThemeSizes',
+    description: 'Override theme sizes',
+  })
+
 export const LikeC4Config_Styles_Theme = z
-  .object({
-    colors: ThemeColorsSchema,
-    sizes: z
-      .object(fromKeys(Sizes, () => DimensionsSchema.optional()))
-      .meta({ description: 'Map of theme sizes.' }),
+  .strictObject({
+    colors: ThemeColorsSchema.optional(),
+    sizes: LikeC4Config_Styles_Theme_Sizes.optional(),
   })
-  .partial()
   .meta({
     id: 'ThemeCustomization',
     description: 'Theme customization',
@@ -186,25 +179,52 @@ export const LikeC4Config_Styles_Theme = z
   })
 export type LikeC4ConfigThemeInput = z.input<typeof LikeC4Config_Styles_Theme>
 
+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
-  .object({
-    color,
-    opacity,
-    border,
-    size,
-    shape,
-    group: z.object({
-      color,
-      opacity,
-      border,
-    }).partial(),
-    relationship: z.object({
-      color,
-      line,
-      arrow,
-    }).partial(),
-  })
-  .partial()
+  .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:
@@ -212,14 +232,13 @@ const LikeC4Config_Styles_Defaults = z
   })
 
 export const LikeC4StylesConfigSchema = z
-  .object({
-    theme: LikeC4Config_Styles_Theme,
-    defaults: LikeC4Config_Styles_Defaults,
+  .strictObject({
+    theme: LikeC4Config_Styles_Theme.optional(),
+    defaults: LikeC4Config_Styles_Defaults.optional(),
     // customCss: z
     //   .array(z.string())
     //   .meta({ description: 'List of custom CSS files' }),
   })
-  .partial()
   .meta({
     id: 'StylesConfiguration',
     description: 'Project styles customization',

package/src/schema.ts

@@ -13,10 +13,25 @@ import type {
 import JSON5 from 'json5'
 import type { SimplifyDeep } from 'type-fest'
 import type { URI } from 'vscode-uri'
-import * as z from 'zod/v4'
+import * as z from 'zod'
 import { ImageAliasesSchema, validateImageAliases } from './schema.image-alias'
 import { LikeC4StylesConfigSchema } from './schema.theme'
 
+export const ManualLayoutsConfigSchema = z
+  .object({
+    outDir: z.string()
+      .meta({
+        description:
+          'Path to the directory where manual layouts will be stored, relative to the folder containing the project config',
+      }),
+  })
+  .meta({
+    id: 'manual-layouts-config',
+    description: 'Configuration for manual layouts',
+  })
+
+export type ManualLayoutsConfig = z.infer<typeof ManualLayoutsConfigSchema>
+
 export const LikeC4ProjectJsonConfigSchema = z.object({
   name: z.string()
     .nonempty('Project name cannot be empty')
@@ -44,6 +59,8 @@ export const LikeC4ProjectJsonConfigSchema = z.object({
   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',
@@ -57,6 +74,41 @@ export const LikeC4ProjectConfigSchema = LikeC4ProjectJsonConfigSchema.extend({
   generators: GeneratorsSchema.optional(),
 })
 
+/**
+ * Result of the {@link GeneratorFnContext.locate} function
+ */
+export type LocateResult = {
+  /**
+   * Range inside the source file
+   */
+  range: {
+    start: {
+      line: number
+      character: number
+    }
+    end: {
+      line: number
+      character: number
+    }
+  }
+  /**
+   * Full path to the source file
+   */
+  document: URI
+  /**
+   * Document path relative to the project folder
+   */
+  relativePath: string
+  /**
+   * Folder, containing the source file ("dirname" of document)
+   */
+  folder: string
+  /**
+   * Source file name ("basename" of document)
+   */
+  filename: string
+}
+
 export interface GeneratorFnContext {
   /**
    * Workspace root directory
@@ -90,37 +142,7 @@ export interface GeneratorFnContext {
       | DeploymentRelationModel
       | LikeC4ViewModel
       | DeploymentElementModel,
-  ): {
-    /**
-     * Range inside the source file
-     */
-    range: {
-      start: {
-        line: number
-        character: number
-      }
-      end: {
-        line: number
-        character: number
-      }
-    }
-    /**
-     * Full path to the source file
-     */
-    document: URI
-    /**
-     * Document path relative to the project folder
-     */
-    relativePath: string
-    /**
-     * Folder, containing the source file ("dirname" of document)
-     */
-    folder: string
-    /**
-     * Source file name ("basename" of document)
-     */
-    filename: string
-  }
+  ): LocateResult
 
   /**
    * Write a file