design-embed 0.1.0

package/node_modules/@design-embed/config/dist/index.js

@@ -0,0 +1,283 @@
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+/**
+ * Helper to define configuration with type safety.
+ *
+ * @param config - The configuration object.
+ * @returns The same configuration object.
+ *
+ * @example
+ * export default defineConfig({
+ *   output: { target: 'react' }
+ * });
+ */
+export function defineConfig(config) {
+    return config;
+}
+/**
+ * Asynchronously loads a configuration file from disk.
+ * Supports .ts, .js, and .mjs files via dynamic import.
+ *
+ * @param configPath - Path to the config file.
+ * @param cwd - Current working directory.
+ * @returns A promise resolving to the load result.
+ */
+export async function loadConfig(configPath, cwd = process.cwd()) {
+    const diagnostics = [];
+    const resolvedPath = isAbsolute(configPath)
+        ? configPath
+        : resolve(cwd, configPath);
+    if (!existsSync(resolvedPath)) {
+        return {
+            diagnostics: [
+                {
+                    code: "CONFIG_NOT_FOUND",
+                    message: `Config file not found: ${resolvedPath}`,
+                    severity: "error",
+                },
+            ],
+        };
+    }
+    if (!/\.(ts|js|mjs)$/.test(resolvedPath)) {
+        return {
+            diagnostics: [
+                {
+                    code: "CONFIG_UNSUPPORTED_FORMAT",
+                    message: `Unsupported config format: ${resolvedPath}. Only .ts, .js, and .mjs are supported.`,
+                    severity: "error",
+                },
+            ],
+        };
+    }
+    try {
+        const module = await import(pathToFileURL(resolvedPath).href);
+        const config = module.default ?? module.config;
+        if (!config) {
+            return {
+                diagnostics: [
+                    {
+                        code: "CONFIG_INVALID",
+                        message: `Config file must export a default object or a named 'config' object: ${resolvedPath}`,
+                        severity: "error",
+                    },
+                ],
+            };
+        }
+        diagnostics.push(...validateConfig(config));
+        diagnostics.push(...validateTransformerPaths(config, dirname(resolvedPath)));
+        return { config, diagnostics };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            diagnostics: [
+                {
+                    code: "CONFIG_INVALID",
+                    message: `Failed to load config file: ${message}`,
+                    severity: "error",
+                },
+            ],
+        };
+    }
+}
+export function validateConfig(config) {
+    const diagnostics = [];
+    const target = config.output?.target;
+    const styleMode = config.output?.styleMode;
+    if (target && target !== "html" && target !== "react") {
+        diagnostics.push({
+            code: "UNSUPPORTED_TARGET",
+            message: `Unsupported output target: ${target}`,
+            severity: "error",
+        });
+    }
+    if (styleMode &&
+        styleMode !== "inline" &&
+        styleMode !== "css-modules" &&
+        styleMode !== "tailwind") {
+        diagnostics.push({
+            code: "STYLE_MODE_UNSUPPORTED",
+            message: `Unsupported style mode: ${styleMode}`,
+            severity: "error",
+        });
+    }
+    for (const [index, component] of (config.components ?? []).entries()) {
+        if (!component.selector || typeof component.selector !== "string") {
+            diagnostics.push({
+                code: "COMPONENT_SELECTOR_INVALID",
+                message: `Component mapping ${index} must include a selector.`,
+                severity: "error",
+            });
+        }
+        if (!component.component || typeof component.component !== "string") {
+            diagnostics.push({
+                code: "COMPONENT_IMPORT_INVALID",
+                message: `Component mapping ${index} must include a component path.`,
+                severity: "error",
+            });
+        }
+    }
+    const spacing = config.tokens?.spacing;
+    if (spacing?.unit && spacing.unit !== "px" && spacing.unit !== "rem") {
+        diagnostics.push({
+            code: "TOKEN_SPACING_UNIT_INVALID",
+            message: `Unsupported spacing unit: ${spacing.unit}`,
+            severity: "error",
+        });
+    }
+    if (spacing?.threshold !== undefined && !Number.isFinite(spacing.threshold)) {
+        diagnostics.push({
+            code: "TOKEN_SPACING_THRESHOLD_INVALID",
+            message: "Spacing threshold must be a finite number.",
+            severity: "error",
+        });
+    }
+    for (const [name, value] of Object.entries(spacing?.values ?? {})) {
+        if (!Number.isFinite(value)) {
+            diagnostics.push({
+                code: "TOKEN_SPACING_VALUE_INVALID",
+                message: `Spacing token ${name} must be a finite number.`,
+                severity: "error",
+            });
+        }
+    }
+    for (const [name, value] of Object.entries(config.tokens?.colors ?? {})) {
+        if (!/^#[0-9a-f]{3}([0-9a-f]{3})?$/i.test(value)) {
+            diagnostics.push({
+                code: "TOKEN_COLOR_INVALID",
+                message: `Color token ${name} must be a hex color.`,
+                severity: "error",
+            });
+        }
+    }
+    if (config.tokens?.colorThreshold !== undefined &&
+        !Number.isFinite(config.tokens.colorThreshold)) {
+        diagnostics.push({
+            code: "TOKEN_COLOR_THRESHOLD_INVALID",
+            message: "Color threshold must be a finite number.",
+            severity: "error",
+        });
+    }
+    for (const [groupName, group] of Object.entries({
+        sizing: config.tokens?.sizing,
+        typography: config.tokens?.typography,
+    })) {
+        if (!group) {
+            continue;
+        }
+        if (group.unit && group.unit !== "px" && group.unit !== "rem") {
+            diagnostics.push({
+                code: "TOKEN_NUMERIC_UNIT_INVALID",
+                message: `Unsupported ${groupName} unit: ${group.unit}`,
+                severity: "error",
+            });
+        }
+        if (group.threshold !== undefined && !Number.isFinite(group.threshold)) {
+            diagnostics.push({
+                code: "TOKEN_NUMERIC_THRESHOLD_INVALID",
+                message: `${groupName} threshold must be a finite number.`,
+                severity: "error",
+            });
+        }
+        for (const [name, value] of Object.entries(group.values ?? {})) {
+            if (!Number.isFinite(value)) {
+                diagnostics.push({
+                    code: "TOKEN_NUMERIC_VALUE_INVALID",
+                    message: `${groupName} token ${name} must be a finite number.`,
+                    severity: "error",
+                });
+            }
+        }
+    }
+    for (const [index, transformer] of (config.transformers ?? []).entries()) {
+        if (!transformer.path || typeof transformer.path !== "string") {
+            diagnostics.push({
+                code: "TRANSFORMER_PATH_INVALID",
+                message: `Transformer ${index} must include a path.`,
+                severity: "error",
+            });
+        }
+        if (transformer.order !== undefined &&
+            !Number.isFinite(transformer.order)) {
+            diagnostics.push({
+                code: "TRANSFORMER_ORDER_INVALID",
+                message: `Transformer ${index} order must be a finite number.`,
+                severity: "error",
+            });
+        }
+    }
+    validateTestGeneration(config.tests, diagnostics);
+    return diagnostics;
+}
+function validateTestGeneration(tests, diagnostics) {
+    if (!tests) {
+        return;
+    }
+    if (tests.runner && tests.runner !== "playwright") {
+        diagnostics.push({
+            code: "TEST_RUNNER_UNSUPPORTED",
+            message: `Unsupported test runner: ${tests.runner}`,
+            severity: "error",
+        });
+    }
+    for (const [index, viewport] of (tests.viewports ?? []).entries()) {
+        if (!Number.isFinite(viewport.width) || viewport.width <= 0) {
+            diagnostics.push({
+                code: "TEST_VIEWPORT_WIDTH_INVALID",
+                message: `Test viewport ${index} width must be a positive finite number.`,
+                severity: "error",
+            });
+        }
+        if (!Number.isFinite(viewport.height) || viewport.height <= 0) {
+            diagnostics.push({
+                code: "TEST_VIEWPORT_HEIGHT_INVALID",
+                message: `Test viewport ${index} height must be a positive finite number.`,
+                severity: "error",
+            });
+        }
+    }
+    for (const [index, state] of (tests.states ?? []).entries()) {
+        if (!state.name || typeof state.name !== "string") {
+            diagnostics.push({
+                code: "TEST_STATE_NAME_INVALID",
+                message: `Test state ${index} must include a name.`,
+                severity: "error",
+            });
+        }
+    }
+    if (tests.assertions?.layoutTolerance !== undefined &&
+        (!Number.isFinite(tests.assertions.layoutTolerance) ||
+            tests.assertions.layoutTolerance < 0)) {
+        diagnostics.push({
+            code: "TEST_LAYOUT_TOLERANCE_INVALID",
+            message: "Test layout tolerance must be a finite number greater than or equal to 0.",
+            severity: "error",
+        });
+    }
+}
+function isPackageName(path) {
+    return !path.startsWith(".") && !isAbsolute(path);
+}
+function validateTransformerPaths(config, configDir) {
+    const diagnostics = [];
+    for (const transformer of config.transformers ?? []) {
+        if (!transformer.path || typeof transformer.path !== "string") {
+            continue;
+        }
+        if (isPackageName(transformer.path)) {
+            continue;
+        }
+        const resolvedPath = isAbsolute(transformer.path)
+            ? transformer.path
+            : resolve(configDir, transformer.path);
+        if (!existsSync(resolvedPath)) {
+            diagnostics.push({
+                code: "TRANSFORMER_NOT_FOUND",
+                message: `Transformer file not found: ${resolvedPath}`,
+                severity: "error",
+            });
+        }
+    }
+    return diagnostics;
+}

package/node_modules/@design-embed/config/package.json

@@ -0,0 +1,19 @@
+{
+	"name": "@design-embed/config",
+	"version": "0.1.0",
+	"type": "module",
+	"private": true,
+	"exports": {
+		".": {
+			"types": "./src/index.ts",
+			"development": "./src/index.ts",
+			"default": "./dist/index.js"
+		}
+	},
+	"files": [
+		"dist",
+		"src",
+		"!src/**/*.test.ts",
+		"README.md"
+	]
+}