@digdir/designsystemet 1.0.6 → 1.0.8

package/dist/config.schema.json

@@ -1,83 +1,95 @@
 {
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
     "$schema": {
       "type": "string"
     },
     "outDir": {
-      "type": "string",
-      "description": "Path to the output directory for the created design tokens"
+      "description": "Path to the output directory for the created design tokens",
+      "type": "string"
     },
     "clean": {
-      "type": "boolean",
-      "description": "Delete the output directory before building or creating tokens"
+      "description": "Delete the output directory before building or creating tokens",
+      "type": "boolean"
     },
     "themes": {
+      "description": "An object with one or more themes. Each property defines a theme, and the property name is used as the theme name.",
       "type": "object",
+      "propertyNames": {
+        "type": "string"
+      },
       "additionalProperties": {
+        "description": "An object defining a theme. The property name holding the object becomes the theme name.",
         "type": "object",
         "properties": {
           "colors": {
+            "description": "Defines the colors for this theme",
             "type": "object",
             "properties": {
               "main": {
+                "description": "An object with one or more color definitions. The property name is used as the color name.",
                 "type": "object",
-                "additionalProperties": {
-                  "type": "string",
-                  "pattern": "^#[0-9a-fA-F]{3}|#[0-9a-fA-F]{4}|#[0-9a-fA-F]{6}|#[0-9a-fA-F]{8}$",
-                  "description": "A hex color, which is used for creating a color scale. Invalid color names: neutral, success, warning, danger, info, blue, green, orange, purple, red"
-                },
                 "propertyNames": {
+                  "type": "string",
                   "pattern": "^(?!(?:neutral|success|warning|danger|info|blue|green|orange|purple|red)$)"
                 },
-                "description": "One or more color definitions"
+                "additionalProperties": {
+                  "description": "A hex color, which is used for creating a color scale. Invalid color names: neutral, success, warning, danger, info, blue, green, orange, purple, red"
+                }
               },
               "support": {
-                "$ref": "#/properties/themes/additionalProperties/properties/colors/properties/main",
-                "default": {}
+                "default": {},
+                "description": "An object with one or more color definitions. The property name is used as the color name.",
+                "type": "object",
+                "propertyNames": {
+                  "type": "string",
+                  "pattern": "^(?!(?:neutral|success|warning|danger|info|blue|green|orange|purple|red)$)"
+                },
+                "additionalProperties": {
+                  "description": "A hex color, which is used for creating a color scale. Invalid color names: neutral, success, warning, danger, info, blue, green, orange, purple, red"
+                }
               },
               "neutral": {
-                "$ref": "#/properties/themes/additionalProperties/properties/colors/properties/main/additionalProperties"
+                "description": "A hex color, which is used for creating a color scale. Invalid color names: neutral, success, warning, danger, info, blue, green, orange, purple, red"
               }
             },
             "required": [
               "main",
+              "support",
               "neutral"
             ],
-            "additionalProperties": false,
-            "description": "Defines the colors for this theme"
+            "additionalProperties": false
           },
           "typography": {
+            "description": "Defines the typography for a given theme",
             "type": "object",
             "properties": {
               "fontFamily": {
-                "type": "string",
-                "description": "Sets the font-family for this theme"
+                "description": "Sets the font-family for this theme",
+                "type": "string"
               }
             },
             "required": [
               "fontFamily"
             ],
-            "additionalProperties": false,
-            "description": "Defines the typography for a given theme"
+            "additionalProperties": false
           },
           "borderRadius": {
-            "type": "number",
-            "description": "Defines the border-radius for this theme"
+            "description": "Defines the border-radius for this theme",
+            "type": "number"
           }
         },
         "required": [
           "colors"
         ],
-        "additionalProperties": false,
-        "description": "An object defining a theme. The property name holding the object becomes the theme name."
-      },
-      "description": "An object with one or more themes. Each property defines a theme, and the property name is used as the theme name."
+        "additionalProperties": false
+      }
     }
   },
   "required": [
+    "outDir",
     "themes"
   ],
-  "additionalProperties": false,
-  "$schema": "http://json-schema.org/draft-07/schema#"
+  "additionalProperties": false
 }

package/dist/src/config.d.ts

@@ -1,207 +1,66 @@
-import { z } from 'zod';
-export declare function mapPathToOptionName(path: (string | number)[]): string | undefined;
+import { z } from 'zod/v4';
+/**
+ * Validates a configuration object against a provided Zod schema.
+ *
+ * @template T - The expected type of the validated configuration.
+ * @param schema - A Zod schema used to validate the configuration object.
+ * @param unvalidatedConfig - The configuration object to validate.
+ * @returns The validated configuration object, typed as T.
+ * @throws Exits the process with code 1 if validation fails, after logging a friendly error message.
+ */
+export declare function validateConfig<T>(schema: z.ZodType<T>, unvalidatedConfig: Record<string, unknown>, configPath: string): T;
+export declare function parseConfig<T>(schema: z.ZodType<T>, configFile: string, configPath: string): T;
 export declare const colorRegex: RegExp;
 declare const themeSchema: z.ZodObject<{
     colors: z.ZodObject<{
-        main: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, `#${string}`, string>>, Record<string, `#${string}`>, Record<string, string>>;
-        support: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, `#${string}`, string>>, Record<string, `#${string}`>, Record<string, string>>>>;
-        neutral: z.ZodEffects<z.ZodString, `#${string}`, string>;
-    }, "strip", z.ZodTypeAny, {
-        neutral: `#${string}`;
-        main: Record<string, `#${string}`>;
-        support: Record<string, `#${string}`>;
-    }, {
-        neutral: string;
-        main: Record<string, string>;
-        support?: Record<string, string> | undefined;
-    }>;
+        main: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+        support: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+        neutral: z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>;
+    }, z.core.$strip>;
     typography: z.ZodOptional<z.ZodObject<{
         fontFamily: z.ZodString;
-    }, "strip", z.ZodTypeAny, {
-        fontFamily: string;
-    }, {
-        fontFamily: string;
-    }>>;
+    }, z.core.$strip>>;
     borderRadius: z.ZodOptional<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    colors: {
-        neutral: `#${string}`;
-        main: Record<string, `#${string}`>;
-        support: Record<string, `#${string}`>;
-    };
-    typography?: {
-        fontFamily: string;
-    } | undefined;
-    borderRadius?: number | undefined;
-}, {
-    colors: {
-        neutral: string;
-        main: Record<string, string>;
-        support?: Record<string, string> | undefined;
-    };
-    typography?: {
-        fontFamily: string;
-    } | undefined;
-    borderRadius?: number | undefined;
-}>;
-/**
- * This defines the structure of the JSON config file
- */
-export declare const configFileSchema: z.ZodObject<{
-    outDir: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const configFileBuildSchema: z.ZodObject<{
     clean: z.ZodOptional<z.ZodBoolean>;
-    themes: z.ZodRecord<z.ZodString, z.ZodObject<{
+}, z.core.$strip>;
+export declare const configFileCreateSchema: z.ZodObject<{
+    outDir: z.ZodNonOptional<z.ZodString>;
+    clean: z.ZodNonOptional<z.ZodOptional<z.ZodBoolean>>;
+    themes: z.ZodNonOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         colors: z.ZodObject<{
-            main: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, `#${string}`, string>>, Record<string, `#${string}`>, Record<string, string>>;
-            support: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, `#${string}`, string>>, Record<string, `#${string}`>, Record<string, string>>>>;
-            neutral: z.ZodEffects<z.ZodString, `#${string}`, string>;
-        }, "strip", z.ZodTypeAny, {
-            neutral: `#${string}`;
-            main: Record<string, `#${string}`>;
-            support: Record<string, `#${string}`>;
-        }, {
-            neutral: string;
-            main: Record<string, string>;
-            support?: Record<string, string> | undefined;
-        }>;
+            main: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            support: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+            neutral: z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>;
+        }, z.core.$strip>;
         typography: z.ZodOptional<z.ZodObject<{
             fontFamily: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            fontFamily: string;
-        }, {
-            fontFamily: string;
-        }>>;
+        }, z.core.$strip>>;
         borderRadius: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        colors: {
-            neutral: `#${string}`;
-            main: Record<string, `#${string}`>;
-            support: Record<string, `#${string}`>;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }, {
-        colors: {
-            neutral: string;
-            main: Record<string, string>;
-            support?: Record<string, string> | undefined;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    themes: Record<string, {
-        colors: {
-            neutral: `#${string}`;
-            main: Record<string, `#${string}`>;
-            support: Record<string, `#${string}`>;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }>;
-    clean?: boolean | undefined;
-    outDir?: string | undefined;
-}, {
-    themes: Record<string, {
-        colors: {
-            neutral: string;
-            main: Record<string, string>;
-            support?: Record<string, string> | undefined;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }>;
-    clean?: boolean | undefined;
-    outDir?: string | undefined;
-}>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
 /**
- * This defines the structure of the final configuration after combining the config file,
- * command-line options and default values.
+ * This defines the structure of the final configuration file
  */
 export declare const combinedConfigSchema: z.ZodObject<{
-    outDir: z.ZodString;
-    clean: z.ZodBoolean;
-    themes: z.ZodRecord<z.ZodString, z.ZodObject<{
+    outDir: z.ZodNonOptional<z.ZodString>;
+    themes: z.ZodNonOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         colors: z.ZodObject<{
-            main: z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, `#${string}`, string>>, Record<string, `#${string}`>, Record<string, string>>;
-            support: z.ZodDefault<z.ZodOptional<z.ZodEffects<z.ZodRecord<z.ZodString, z.ZodEffects<z.ZodString, `#${string}`, string>>, Record<string, `#${string}`>, Record<string, string>>>>;
-            neutral: z.ZodEffects<z.ZodString, `#${string}`, string>;
-        }, "strip", z.ZodTypeAny, {
-            neutral: `#${string}`;
-            main: Record<string, `#${string}`>;
-            support: Record<string, `#${string}`>;
-        }, {
-            neutral: string;
-            main: Record<string, string>;
-            support?: Record<string, string> | undefined;
-        }>;
+            main: z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>;
+            support: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>>>>;
+            neutral: z.ZodPipe<z.ZodString, z.ZodTransform<`#${string}`, string>>;
+        }, z.core.$strip>;
         typography: z.ZodOptional<z.ZodObject<{
             fontFamily: z.ZodString;
-        }, "strip", z.ZodTypeAny, {
-            fontFamily: string;
-        }, {
-            fontFamily: string;
-        }>>;
+        }, z.core.$strip>>;
         borderRadius: z.ZodOptional<z.ZodNumber>;
-    }, "strip", z.ZodTypeAny, {
-        colors: {
-            neutral: `#${string}`;
-            main: Record<string, `#${string}`>;
-            support: Record<string, `#${string}`>;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }, {
-        colors: {
-            neutral: string;
-            main: Record<string, string>;
-            support?: Record<string, string> | undefined;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }>>;
-}, "strip", z.ZodTypeAny, {
-    clean: boolean;
-    themes: Record<string, {
-        colors: {
-            neutral: `#${string}`;
-            main: Record<string, `#${string}`>;
-            support: Record<string, `#${string}`>;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }>;
-    outDir: string;
-}, {
-    clean: boolean;
-    themes: Record<string, {
-        colors: {
-            neutral: string;
-            main: Record<string, string>;
-            support?: Record<string, string> | undefined;
-        };
-        typography?: {
-            fontFamily: string;
-        } | undefined;
-        borderRadius?: number | undefined;
-    }>;
-    outDir: string;
-}>;
-export type Config = z.infer<typeof combinedConfigSchema>;
-export type ThemeConfig = z.infer<typeof themeSchema>;
+    }, z.core.$strip>>>;
+    clean: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ConfigSchema = z.infer<typeof combinedConfigSchema>;
+export type ConfigSchemaBuild = z.infer<typeof configFileBuildSchema>;
+export type ConfigSchemaCreate = z.infer<typeof configFileCreateSchema>;
+export type ConfigSchemaTheme = z.infer<typeof themeSchema>;
 export {};
 //# sourceMappingURL=config.d.ts.map

package/dist/src/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,sBAQ5D;AAWD,eAAO,MAAM,UAAU,QAA2C,CAAC;AAwBnE,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqBhB,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAO3B,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA8B,CAAC;AAChE,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAgC3B;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EACpB,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC1C,UAAU,EAAE,MAAM,GACjB,CAAC,CASH;AAED,wBAAgB,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,CAAC,CAc9F;AAWD,eAAO,MAAM,UAAU,QAA2C,CAAC;AAyBnE,QAAA,MAAM,WAAW;;;;;;;;;;iBAiBmG,CAAC;AAErH,eAAO,MAAM,qBAAqB;;iBAEhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;iBAYtB,CAAC;AAEd;;GAEG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;iBAA6D,CAAC;AAC/F,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAChE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACxE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/src/config.js

@@ -1,6 +1,8 @@
 // src/config.ts
+import chalk from "chalk";
 import * as R7 from "ramda";
-import { z } from "zod";
+import { fromError } from "zod-validation-error";
+import { z } from "zod/v4";
 
 // src/colors/utils.ts
 import chroma from "chroma-js";
@@ -318,6 +320,42 @@ function mapPathToOptionName(path2) {
   }
   return option;
 }
+function makeFriendlyError(err) {
+  return fromError(err, {
+    messageBuilder: (issues) => issues.map((issue) => {
+      const issuePath = issue.path.join(".");
+      const optionName = mapPathToOptionName(issue.path);
+      const errorCode = `(error code: ${issue.code})`;
+      const optionMessage = optionName ? ` or CLI option --${optionName}` : "";
+      return `  - Error in JSON value ${chalk.red(issuePath)}${optionMessage}:
+    ${issue.message} ${chalk.dim(errorCode)}`;
+    }).join("\n")
+  });
+}
+function validateConfig(schema, unvalidatedConfig, configPath) {
+  try {
+    return schema.parse(unvalidatedConfig);
+  } catch (err) {
+    console.error(chalk.redBright(`Invalid config file at ${chalk.red(configPath)}`));
+    const validationError = makeFriendlyError(err);
+    console.error(validationError.toString());
+    process.exit(1);
+  }
+}
+function parseConfig(schema, configFile, configPath) {
+  if (!configFile) {
+    return {};
+  }
+  try {
+    const parsedConfig = JSON.parse(configFile);
+    return schema.parse(parsedConfig);
+  } catch (err) {
+    console.error(chalk.redBright(`Failed parsing config file at ${chalk.red(configPath)}`));
+    const validationError = makeFriendlyError(err);
+    console.error(validationError.toString());
+    process.exit(1);
+  }
+}
 var hexPatterns = [
   // Hex colors: #000, #0000, #000000, #00000000
   `#[0-9a-fA-F]{3}`,
@@ -327,52 +365,47 @@ var hexPatterns = [
 ];
 var reservedColorsPattern = `^(?!(?:${RESERVED_COLORS.join("|")})$)`;
 var colorRegex = new RegExp(`^${hexPatterns.join("|")}$`);
-var colorSchema = z.string({
-  description: `A hex color, which is used for creating a color scale. Invalid color names: ${RESERVED_COLORS.join(", ")}`
-}).regex(colorRegex).transform(convertToHex);
+var colorSchema = z.string().regex(colorRegex).transform(convertToHex).describe(
+  `A hex color, which is used for creating a color scale. Invalid color names: ${RESERVED_COLORS.join(", ")}`
+);
 var colorCategorySchema = z.record(
   z.string().regex(new RegExp(reservedColorsPattern, "i"), {
-    message: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
+    error: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
   }),
   colorSchema,
   {
-    description: "One or more color definitions",
-    invalid_type_error: "Color definitions must be hex color values"
+    error: "Color definitions must be hex color values"
   }
 ).refine((colors) => !Object.keys(colors).some((key) => RESERVED_COLORS.includes(key.toLowerCase())), {
-  message: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
+  error: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
+}).describe("An object with one or more color definitions. The property name is used as the color name.");
+var themeSchema = z.object({
+  colors: z.object({
+    main: colorCategorySchema,
+    support: colorCategorySchema.optional().default({}),
+    neutral: colorSchema
+  }).meta({ description: "Defines the colors for this theme" }),
+  typography: z.object({
+    fontFamily: z.string().meta({ description: "Sets the font-family for this theme" })
+  }).describe("Defines the typography for a given theme").optional(),
+  borderRadius: z.number().meta({ description: "Defines the border-radius for this theme" }).optional()
+}).meta({ description: "An object defining a theme. The property name holding the object becomes the theme name." });
+var configFileBuildSchema = z.object({
+  clean: z.boolean().meta({ description: "Delete the output directory before building or creating tokens" }).optional()
 });
-var themeSchema = z.object(
-  {
-    colors: z.object(
-      {
-        main: colorCategorySchema,
-        support: colorCategorySchema.optional().default({}),
-        neutral: colorSchema
-      },
-      { description: "Defines the colors for this theme" }
-    ),
-    typography: z.object(
-      {
-        fontFamily: z.string({ description: "Sets the font-family for this theme" })
-      },
-      { description: "Defines the typography for a given theme" }
-    ).optional(),
-    borderRadius: z.number({ description: "Defines the border-radius for this theme" }).optional()
-  },
-  { description: "An object defining a theme. The property name holding the object becomes the theme name." }
-);
-var configFileSchema = z.object({
-  outDir: z.string({ description: "Path to the output directory for the created design tokens" }).optional(),
-  clean: z.boolean({ description: "Delete the output directory before building or creating tokens" }).optional(),
-  themes: z.record(themeSchema, {
+var configFileCreateSchema = z.object({
+  outDir: z.string().meta({ description: "Path to the output directory for the created design tokens" }),
+  clean: z.boolean().meta({ description: "Delete the output directory before building or creating tokens" }).optional(),
+  themes: z.record(z.string(), themeSchema).meta({
     description: "An object with one or more themes. Each property defines a theme, and the property name is used as the theme name."
   })
-});
-var combinedConfigSchema = configFileSchema.required();
+}).required();
+var combinedConfigSchema = configFileCreateSchema.extend(configFileBuildSchema.shape);
 export {
   colorRegex,
   combinedConfigSchema,
-  configFileSchema,
-  mapPathToOptionName
+  configFileBuildSchema,
+  configFileCreateSchema,
+  parseConfig,
+  validateConfig
 };