@styleframe/cli 3.0.0 → 4.1.0

package/dist/commands/figma/export.d.ts

@@ -0,0 +1,24 @@
+declare const _default: import('citty').CommandDef<{
+    config: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+        valueHint: string;
+    };
+    output: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+        valueHint: string;
+    };
+    collection: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+    };
+}>;
+export default _default;
+//# sourceMappingURL=export.d.ts.map

package/dist/commands/figma/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../../src/commands/figma/export.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;AASA,wBAgGG"}

package/dist/commands/figma/import.d.ts

@@ -0,0 +1,38 @@
+declare const _default: import('citty').CommandDef<{
+    input: {
+        type: "string";
+        description: string;
+        required: true;
+        alias: string[];
+        valueHint: string;
+    };
+    output: {
+        type: "string";
+        description: string;
+        default: string;
+        alias: string[];
+        valueHint: string;
+    };
+    composables: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    rem: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    baseFontSize: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    instanceName: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+}>;
+export default _default;
+//# sourceMappingURL=import.d.ts.map

package/dist/commands/figma/import.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../src/commands/figma/import.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAYA,wBA0HG"}

package/dist/commands/figma/index.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import('citty').CommandDef<import('citty').ArgsDef>;
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/figma/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/figma/index.ts"],"names":[],"mappings":";AAEA,wBAUG"}

package/dist/commands/init/nuxt.d.ts

@@ -0,0 +1,2 @@
+export declare function initializeNuxtFrameworkFile(cwd: string): Promise<void>;
+//# sourceMappingURL=nuxt.d.ts.map

package/dist/commands/init/nuxt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nuxt.d.ts","sourceRoot":"","sources":["../../../src/commands/init/nuxt.ts"],"names":[],"mappings":"AASA,wBAAsB,2BAA2B,CAAC,GAAG,EAAE,MAAM,iBAqB5D"}

package/dist/commands/init/vite.d.ts

@@ -0,0 +1,2 @@
+export declare function initializeViteFrameworkFile(cwd: string): Promise<void>;
+//# sourceMappingURL=vite.d.ts.map

package/dist/commands/init/vite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vite.d.ts","sourceRoot":"","sources":["../../../src/commands/init/vite.ts"],"names":[],"mappings":"AASA,wBAAsB,2BAA2B,CAAC,GAAG,EAAE,MAAM,iBAyB5D"}

package/dist/commands/init.d.ts

@@ -0,0 +1,26 @@
+interface TsConfigOptions {
+    /**
+     * Whether to add a `compilerOptions.paths` entry mapping `virtual:styleframe`
+     * to `styleframe.d.ts`. Required for type-checkers that cannot resolve a
+     * bare-specifier ambient `declare module` (e.g. `vue-tsc` inside `.vue` SFCs).
+     * When false, both virtual modules resolve from the ambient `shims.d.ts`
+     * (picked up via the includes) with zero extra config.
+     */
+    paths: boolean;
+}
+export declare function initializeConfigFile(cwd: string): Promise<void>;
+export declare function initializeTsConfig(cwd: string, options: TsConfigOptions): Promise<void>;
+export declare function addPackageJsonDependencies(cwd: string): Promise<void>;
+export declare function initializeFrameworkFile(cwd: string): Promise<void>;
+declare const _default: import('citty').CommandDef<{
+    cwd: {
+        type: "string";
+        required: false;
+        default: string;
+        description: string;
+        alias: string[];
+        valueHint: string;
+    };
+}>;
+export default _default;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AA+BA,UAAU,eAAe;IACxB;;;;;;OAMG;IACH,KAAK,EAAE,OAAO,CAAC;CACf;AA+CD,wBAAsB,oBAAoB,CAAC,GAAG,EAAE,MAAM,iBAWrD;AAuBD,wBAAsB,kBAAkB,CACvC,GAAG,EAAE,MAAM,EACX,OAAO,EAAE,eAAe,iBAyCxB;AAED,wBAAsB,0BAA0B,CAAC,GAAG,EAAE,MAAM,iBAsB3D;AAED,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,MAAM,iBAWxD;;;;;;;;;;;AAED,wBA2BG"}

package/dist/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const HOMEPAGE_URL = "https://styleframe.dev";
+export declare const DOCS_URL = "https://styleframe.dev/docs";
+export declare const DOCS_INSTALLATION_VITE_URL = "https://styleframe.dev/docs/getting-started/installation/vite";
+export declare const DOCS_MANUAL_INSTALLATION_VITE_URL = "https://styleframe.dev/docs/getting-started/installation/manual/vite";
+export declare const DOCS_INSTALLATION_NUXT_URL = "https://styleframe.dev/docs/getting-started/installation/nuxt";
+export declare const DOCS_MANUAL_INSTALLATION_NUXT_URL = "https://styleframe.dev/docs/getting-started/installation/manual/nuxt";
+export declare const DOCS_INSTALLATION_CUSTOM_URL = "https://styleframe.dev/docs/getting-started/installation/custom";
+//# sourceMappingURL=constants.d.ts.map

package/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,2BAA2B,CAAC;AACrD,eAAO,MAAM,QAAQ,gCAAyB,CAAC;AAC/C,eAAO,MAAM,0BAA0B,kEAAkD,CAAC;AAC1F,eAAO,MAAM,iCAAiC,yEAAyD,CAAC;AACxG,eAAO,MAAM,0BAA0B,kEAAkD,CAAC;AAC1F,eAAO,MAAM,iCAAiC,yEAAyD,CAAC;AACxG,eAAO,MAAM,4BAA4B,oEAAoD,CAAC"}

package/dist/dtcg-D1-iITOr.js

@@ -0,0 +1,14 @@
+import { defineCommand } from "citty";
+//#region src/commands/dtcg/index.ts
+var dtcg_default = defineCommand({
+	meta: {
+		name: "dtcg",
+		description: "Export Styleframe variables to and import them from DTCG format"
+	},
+	subCommands: {
+		export: () => import("./export-CBdPGGEq.js").then((m) => m.default),
+		import: () => import("./import-MqLYxb8d.js").then((m) => m.default)
+	}
+});
+//#endregion
+export { dtcg_default as default };

package/dist/dtcg-D84AfyzO.cjs

@@ -0,0 +1,13 @@
+//#region src/commands/dtcg/index.ts
+var dtcg_default = (0, require("citty").defineCommand)({
+	meta: {
+		name: "dtcg",
+		description: "Export Styleframe variables to and import them from DTCG format"
+	},
+	subCommands: {
+		export: () => Promise.resolve().then(() => require("./export-DmPAU9Wh.cjs")).then((m) => m.default),
+		import: () => Promise.resolve().then(() => require("./import-ibQc_GXm.cjs")).then((m) => m.default)
+	}
+});
+//#endregion
+exports.default = dtcg_default;

package/dist/export-CBdPGGEq.js

@@ -0,0 +1,66 @@
+import { t as buildDTCG } from "./build-dtcg-BpbjBRCf.js";
+import { defineCommand } from "citty";
+import path from "node:path";
+import { loadConfiguration } from "@styleframe/loader";
+import consola from "consola";
+import { mkdir, writeFile } from "node:fs/promises";
+//#region src/commands/dtcg/export.ts
+var export_default = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export Styleframe variables to spec-conformant DTCG JSON"
+	},
+	args: {
+		config: {
+			type: "string",
+			description: "Path to the Styleframe config file",
+			default: "styleframe.config.ts",
+			alias: ["c"],
+			valueHint: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output directory for DTCG files",
+			default: ".",
+			alias: ["o"],
+			valueHint: "path"
+		},
+		collection: {
+			type: "string",
+			description: "Collection name embedded in the export",
+			default: "Design Tokens",
+			alias: ["n", "name"]
+		}
+	},
+	async run({ args }) {
+		const configPath = path.resolve(args.config);
+		const outputDir = path.resolve(args.output);
+		consola.info(`Loading configuration from "${path.relative(process.cwd(), configPath)}"...`);
+		const root = (await loadConfiguration({ entry: configPath })).root;
+		consola.info("Building DTCG document...");
+		const { tokens, resolver, diagnostics, emittedCount, fluidNormalisedCount, maxViewport } = buildDTCG(root, {
+			collectionName: args.collection,
+			tokensSourceRef: "tokens.json"
+		});
+		await mkdir(outputDir, { recursive: true });
+		const tokensPath = path.join(outputDir, "tokens.json");
+		await writeFile(tokensPath, `${JSON.stringify(tokens, null, 2)}\n`);
+		consola.info(`Wrote ${emittedCount} tokens to "${path.relative(process.cwd(), tokensPath)}"`);
+		if (fluidNormalisedCount > 0) consola.info(`Normalised ${fluidNormalisedCount} fluid token(s) using max viewport (${maxViewport}px).`);
+		if (resolver) {
+			const resolverPath = path.join(outputDir, "tokens.resolver.json");
+			await writeFile(resolverPath, `${JSON.stringify(resolver, null, 2)}\n`);
+			consola.info(`Wrote resolver to "${path.relative(process.cwd(), resolverPath)}"`);
+		}
+		const warnings = diagnostics.filter((d) => d.level === "warn");
+		if (warnings.length > 0) {
+			consola.warn(`${warnings.length} variable(s) needed special handling — see Styleframe ↔ DTCG round-trip notes`);
+			for (const w of warnings.slice(0, 10)) consola.info(`  - ${w.name}: ${w.reason}`);
+			if (warnings.length > 10) consola.info(`  ... and ${warnings.length - 10} more`);
+			consola.info("Tip: untyped tokens are usually CSS keywords (e.g. \"normal\", \"thin\", \"italic\") with no DTCG equivalent — they round-trip to Figma as STRING variables.");
+		}
+		consola.success(`Exported ${emittedCount} tokens in DTCG format to "${path.relative(process.cwd(), outputDir)}"`);
+	}
+});
+//#endregion
+export { export_default as default };

package/dist/export-DmPAU9Wh.cjs

@@ -0,0 +1,69 @@
+const require_chunk = require("./chunk-D6vf50IK.cjs");
+const require_build_dtcg = require("./build-dtcg-vuGHy-Sl.cjs");
+let citty = require("citty");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+let _styleframe_loader = require("@styleframe/loader");
+let consola = require("consola");
+consola = require_chunk.__toESM(consola, 1);
+let node_fs_promises = require("node:fs/promises");
+//#region src/commands/dtcg/export.ts
+var export_default = (0, citty.defineCommand)({
+	meta: {
+		name: "export",
+		description: "Export Styleframe variables to spec-conformant DTCG JSON"
+	},
+	args: {
+		config: {
+			type: "string",
+			description: "Path to the Styleframe config file",
+			default: "styleframe.config.ts",
+			alias: ["c"],
+			valueHint: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output directory for DTCG files",
+			default: ".",
+			alias: ["o"],
+			valueHint: "path"
+		},
+		collection: {
+			type: "string",
+			description: "Collection name embedded in the export",
+			default: "Design Tokens",
+			alias: ["n", "name"]
+		}
+	},
+	async run({ args }) {
+		const configPath = node_path.default.resolve(args.config);
+		const outputDir = node_path.default.resolve(args.output);
+		consola.default.info(`Loading configuration from "${node_path.default.relative(process.cwd(), configPath)}"...`);
+		const root = (await (0, _styleframe_loader.loadConfiguration)({ entry: configPath })).root;
+		consola.default.info("Building DTCG document...");
+		const { tokens, resolver, diagnostics, emittedCount, fluidNormalisedCount, maxViewport } = require_build_dtcg.buildDTCG(root, {
+			collectionName: args.collection,
+			tokensSourceRef: "tokens.json"
+		});
+		await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
+		const tokensPath = node_path.default.join(outputDir, "tokens.json");
+		await (0, node_fs_promises.writeFile)(tokensPath, `${JSON.stringify(tokens, null, 2)}\n`);
+		consola.default.info(`Wrote ${emittedCount} tokens to "${node_path.default.relative(process.cwd(), tokensPath)}"`);
+		if (fluidNormalisedCount > 0) consola.default.info(`Normalised ${fluidNormalisedCount} fluid token(s) using max viewport (${maxViewport}px).`);
+		if (resolver) {
+			const resolverPath = node_path.default.join(outputDir, "tokens.resolver.json");
+			await (0, node_fs_promises.writeFile)(resolverPath, `${JSON.stringify(resolver, null, 2)}\n`);
+			consola.default.info(`Wrote resolver to "${node_path.default.relative(process.cwd(), resolverPath)}"`);
+		}
+		const warnings = diagnostics.filter((d) => d.level === "warn");
+		if (warnings.length > 0) {
+			consola.default.warn(`${warnings.length} variable(s) needed special handling — see Styleframe ↔ DTCG round-trip notes`);
+			for (const w of warnings.slice(0, 10)) consola.default.info(`  - ${w.name}: ${w.reason}`);
+			if (warnings.length > 10) consola.default.info(`  ... and ${warnings.length - 10} more`);
+			consola.default.info("Tip: untyped tokens are usually CSS keywords (e.g. \"normal\", \"thin\", \"italic\") with no DTCG equivalent — they round-trip to Figma as STRING variables.");
+		}
+		consola.default.success(`Exported ${emittedCount} tokens in DTCG format to "${node_path.default.relative(process.cwd(), outputDir)}"`);
+	}
+});
+//#endregion
+exports.default = export_default;

package/dist/export-ONk9eKoZ.cjs

@@ -0,0 +1,86 @@
+const require_chunk = require("./chunk-D6vf50IK.cjs");
+const require_build_dtcg = require("./build-dtcg-vuGHy-Sl.cjs");
+let citty = require("citty");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+let _styleframe_loader = require("@styleframe/loader");
+let consola = require("consola");
+consola = require_chunk.__toESM(consola, 1);
+let node_fs_promises = require("node:fs/promises");
+let _styleframe_figma = require("@styleframe/figma");
+//#region src/commands/figma/export.ts
+var export_default = (0, citty.defineCommand)({
+	meta: {
+		name: "export",
+		description: "Export Styleframe variables to Figma-compatible DTCG format (per-mode files)"
+	},
+	args: {
+		config: {
+			type: "string",
+			description: "Path to the Styleframe config file",
+			default: "styleframe.config.ts",
+			alias: ["c"],
+			valueHint: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output directory for per-mode .tokens.json files",
+			default: ".",
+			alias: ["o"],
+			valueHint: "path"
+		},
+		collection: {
+			type: "string",
+			description: "Collection name embedded in the export",
+			default: "Design Tokens",
+			alias: ["n", "name"]
+		}
+	},
+	async run({ args }) {
+		const configPath = node_path.default.resolve(args.config);
+		const outputDir = node_path.default.resolve(args.output);
+		consola.default.info(`Loading configuration from "${node_path.default.relative(process.cwd(), configPath)}"...`);
+		const root = (await (0, _styleframe_loader.loadConfiguration)({ entry: configPath })).root;
+		consola.default.info("Building DTCG document...");
+		const { tokens, resolver, diagnostics: buildDiags, emittedCount, fluidNormalisedCount, maxViewport } = require_build_dtcg.buildDTCG(root, { collectionName: args.collection });
+		consola.default.info("Flattening to Figma-compatible format...");
+		const { modes, diagnostics: flattenDiags } = await (0, _styleframe_figma.flattenToFigmaDTCG)(tokens, resolver);
+		await (0, node_fs_promises.mkdir)(outputDir, { recursive: true });
+		for (const [modeName, modeDoc] of Object.entries(modes)) {
+			const filename = `${modeName}.tokens.json`;
+			const filePath = node_path.default.join(outputDir, filename);
+			await (0, node_fs_promises.writeFile)(filePath, `${JSON.stringify(modeDoc, null, 2)}\n`);
+			const tokenCount = countTokens(modeDoc);
+			consola.default.info(`Wrote "${node_path.default.relative(process.cwd(), filePath)}" (${tokenCount} tokens)`);
+		}
+		if (fluidNormalisedCount > 0) consola.default.info(`Normalised ${fluidNormalisedCount} fluid token(s) using max viewport (${maxViewport}px).`);
+		const allDiags = [...buildDiags.filter((d) => d.level === "warn"), ...flattenDiags];
+		if (allDiags.length > 0) {
+			consola.default.warn(`${allDiags.length} token(s) needed special handling`);
+			for (const d of allDiags.slice(0, 10)) {
+				const name = "name" in d ? d.name : d.path;
+				const reason = "reason" in d ? d.reason : "";
+				consola.default.info(`  - ${name}: ${reason}`);
+			}
+			if (allDiags.length > 10) consola.default.info(`  ... and ${allDiags.length - 10} more`);
+		}
+		consola.default.success(`Exported ${emittedCount} tokens as ${Object.keys(modes).length} Figma-compatible mode file(s) to "${node_path.default.relative(process.cwd(), outputDir)}"`);
+	}
+});
+function countTokens(doc) {
+	let count = 0;
+	for (const [key, value] of Object.entries(doc)) {
+		if (key === "$root") {
+			if (typeof value === "object" && value !== null && !Array.isArray(value) && "$value" in value) count++;
+			continue;
+		}
+		if (key.startsWith("$")) continue;
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			if ("$value" in value) count++;
+			count += countTokens(value);
+		}
+	}
+	return count;
+}
+//#endregion
+exports.default = export_default;

package/dist/export-suUS16eO.js

@@ -0,0 +1,83 @@
+import { t as buildDTCG } from "./build-dtcg-BpbjBRCf.js";
+import { defineCommand } from "citty";
+import path from "node:path";
+import { loadConfiguration } from "@styleframe/loader";
+import consola from "consola";
+import { mkdir, writeFile } from "node:fs/promises";
+import { flattenToFigmaDTCG } from "@styleframe/figma";
+//#region src/commands/figma/export.ts
+var export_default = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export Styleframe variables to Figma-compatible DTCG format (per-mode files)"
+	},
+	args: {
+		config: {
+			type: "string",
+			description: "Path to the Styleframe config file",
+			default: "styleframe.config.ts",
+			alias: ["c"],
+			valueHint: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output directory for per-mode .tokens.json files",
+			default: ".",
+			alias: ["o"],
+			valueHint: "path"
+		},
+		collection: {
+			type: "string",
+			description: "Collection name embedded in the export",
+			default: "Design Tokens",
+			alias: ["n", "name"]
+		}
+	},
+	async run({ args }) {
+		const configPath = path.resolve(args.config);
+		const outputDir = path.resolve(args.output);
+		consola.info(`Loading configuration from "${path.relative(process.cwd(), configPath)}"...`);
+		const root = (await loadConfiguration({ entry: configPath })).root;
+		consola.info("Building DTCG document...");
+		const { tokens, resolver, diagnostics: buildDiags, emittedCount, fluidNormalisedCount, maxViewport } = buildDTCG(root, { collectionName: args.collection });
+		consola.info("Flattening to Figma-compatible format...");
+		const { modes, diagnostics: flattenDiags } = await flattenToFigmaDTCG(tokens, resolver);
+		await mkdir(outputDir, { recursive: true });
+		for (const [modeName, modeDoc] of Object.entries(modes)) {
+			const filename = `${modeName}.tokens.json`;
+			const filePath = path.join(outputDir, filename);
+			await writeFile(filePath, `${JSON.stringify(modeDoc, null, 2)}\n`);
+			const tokenCount = countTokens(modeDoc);
+			consola.info(`Wrote "${path.relative(process.cwd(), filePath)}" (${tokenCount} tokens)`);
+		}
+		if (fluidNormalisedCount > 0) consola.info(`Normalised ${fluidNormalisedCount} fluid token(s) using max viewport (${maxViewport}px).`);
+		const allDiags = [...buildDiags.filter((d) => d.level === "warn"), ...flattenDiags];
+		if (allDiags.length > 0) {
+			consola.warn(`${allDiags.length} token(s) needed special handling`);
+			for (const d of allDiags.slice(0, 10)) {
+				const name = "name" in d ? d.name : d.path;
+				const reason = "reason" in d ? d.reason : "";
+				consola.info(`  - ${name}: ${reason}`);
+			}
+			if (allDiags.length > 10) consola.info(`  ... and ${allDiags.length - 10} more`);
+		}
+		consola.success(`Exported ${emittedCount} tokens as ${Object.keys(modes).length} Figma-compatible mode file(s) to "${path.relative(process.cwd(), outputDir)}"`);
+	}
+});
+function countTokens(doc) {
+	let count = 0;
+	for (const [key, value] of Object.entries(doc)) {
+		if (key === "$root") {
+			if (typeof value === "object" && value !== null && !Array.isArray(value) && "$value" in value) count++;
+			continue;
+		}
+		if (key.startsWith("$")) continue;
+		if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+			if ("$value" in value) count++;
+			count += countTokens(value);
+		}
+	}
+	return count;
+}
+//#endregion
+export { export_default as default };

package/dist/figma-BvXoqRPU.cjs

@@ -0,0 +1,13 @@
+//#region src/commands/figma/index.ts
+var figma_default = (0, require("citty").defineCommand)({
+	meta: {
+		name: "figma",
+		description: "Export and import Figma-compatible DTCG format (per-mode files)"
+	},
+	subCommands: {
+		export: () => Promise.resolve().then(() => require("./export-ONk9eKoZ.cjs")).then((m) => m.default),
+		import: () => Promise.resolve().then(() => require("./import-BQrcHNjK.cjs")).then((m) => m.default)
+	}
+});
+//#endregion
+exports.default = figma_default;

package/dist/figma-D2RJh56T.js

@@ -0,0 +1,14 @@
+import { defineCommand } from "citty";
+//#region src/commands/figma/index.ts
+var figma_default = defineCommand({
+	meta: {
+		name: "figma",
+		description: "Export and import Figma-compatible DTCG format (per-mode files)"
+	},
+	subCommands: {
+		export: () => import("./export-suUS16eO.js").then((m) => m.default),
+		import: () => import("./import-Bll_uBvJ.js").then((m) => m.default)
+	}
+});
+//#endregion
+export { figma_default as default };

package/dist/import-BQrcHNjK.cjs

@@ -0,0 +1,126 @@
+const require_chunk = require("./chunk-D6vf50IK.cjs");
+let citty = require("citty");
+let node_path = require("node:path");
+node_path = require_chunk.__toESM(node_path, 1);
+let consola = require("consola");
+consola = require_chunk.__toESM(consola, 1);
+let node_fs_promises = require("node:fs/promises");
+let _styleframe_figma = require("@styleframe/figma");
+//#region src/commands/figma/import.ts
+var import_default = (0, citty.defineCommand)({
+	meta: {
+		name: "import",
+		description: "Generate Styleframe code from Figma-compatible DTCG per-mode files"
+	},
+	args: {
+		input: {
+			type: "string",
+			description: "Input .tokens.json file or directory of per-mode files",
+			required: true,
+			alias: ["i"],
+			valueHint: "path"
+		},
+		output: {
+			type: "string",
+			description: "Output Styleframe TypeScript file path",
+			default: "tokens.styleframe.ts",
+			alias: ["o"],
+			valueHint: "path"
+		},
+		composables: {
+			type: "boolean",
+			description: "Use @styleframe/theme composables (useColor, useSpacing, etc.)",
+			default: true
+		},
+		rem: {
+			type: "boolean",
+			description: "Use rem units for dimensions instead of px",
+			default: false
+		},
+		baseFontSize: {
+			type: "string",
+			description: "Base font size for rem conversion (in pixels)",
+			default: "16"
+		},
+		instanceName: {
+			type: "string",
+			description: "Name for the Styleframe instance variable",
+			default: "s"
+		}
+	},
+	async run({ args }) {
+		const inputPath = node_path.default.resolve(args.input);
+		const outputPath = node_path.default.resolve(args.output);
+		const baseFontSize = Number.parseInt(args.baseFontSize, 10) || 16;
+		consola.default.info(`Reading from "${node_path.default.relative(process.cwd(), inputPath)}"...`);
+		let data;
+		try {
+			if ((await (0, node_fs_promises.stat)(inputPath)).isDirectory()) {
+				const tokenFiles = (await (0, node_fs_promises.readdir)(inputPath)).filter((f) => f.endsWith(".tokens.json")).sort();
+				if (tokenFiles.length === 0) {
+					consola.default.error(`No .tokens.json files found in "${node_path.default.relative(process.cwd(), inputPath)}"`);
+					process.exit(1);
+				}
+				consola.default.info(`Found ${tokenFiles.length} mode file(s): ${tokenFiles.join(", ")}`);
+				const modeFormats = [];
+				for (const file of tokenFiles) {
+					const content = await (0, node_fs_promises.readFile)(node_path.default.join(inputPath, file), "utf-8");
+					const rawDoc = JSON.parse(content);
+					const modeData = (0, _styleframe_figma.fromDTCG)(rawDoc, { defaultModeName: extractModeName(rawDoc, file) });
+					modeFormats.push(modeData);
+				}
+				data = mergeModeFormats(modeFormats);
+			} else {
+				const content = await (0, node_fs_promises.readFile)(inputPath, "utf-8");
+				data = (0, _styleframe_figma.fromDTCG)(JSON.parse(content));
+			}
+		} catch (error) {
+			consola.default.error(`Failed to read or parse input: ${error instanceof Error ? error.message : error}`);
+			process.exit(1);
+		}
+		consola.default.info(`Generating Styleframe code for ${data.variables.length} variables...`);
+		const result = (0, _styleframe_figma.generateStyleframeCode)(data, {
+			useComposables: args.composables,
+			useRem: args.rem,
+			baseFontSize,
+			instanceName: args.instanceName
+		});
+		consola.default.info(`Writing to "${node_path.default.relative(process.cwd(), outputPath)}"...`);
+		await (0, node_fs_promises.writeFile)(outputPath, result.code);
+		consola.default.success("Generated Styleframe code with:");
+		consola.default.info(`  - ${result.variables.length} variables`);
+		consola.default.info(`  - ${result.themes.length} theme(s)`);
+		if (args.composables && result.imports.length > 1) consola.default.info(`  - Using composables: ${result.imports.slice(1).join(", ")}`);
+		consola.default.info(`\nOutput: ${node_path.default.relative(process.cwd(), outputPath)}`);
+	}
+});
+function extractModeName(doc, filename) {
+	const ext = doc.$extensions;
+	if (ext && typeof ext["com.figma.modeName"] === "string") return ext["com.figma.modeName"];
+	const sfExt = ext?.["dev.styleframe"];
+	if (sfExt && typeof sfExt.modeName === "string") return sfExt.modeName;
+	return filename.replace(/\.tokens\.json$/, "");
+}
+function mergeModeFormats(formats) {
+	if (formats.length === 1) return formats[0];
+	const allModes = [];
+	const variableMap = /* @__PURE__ */ new Map();
+	for (const format of formats) {
+		for (const mode of format.modes) if (!allModes.includes(mode)) allModes.push(mode);
+		for (const v of format.variables) {
+			const existing = variableMap.get(v.name);
+			if (existing) Object.assign(existing.values, v.values);
+			else variableMap.set(v.name, {
+				...v,
+				values: { ...v.values }
+			});
+		}
+	}
+	return {
+		collection: formats[0].collection,
+		modes: allModes,
+		variables: [...variableMap.values()]
+	};
+}
+//#endregion
+exports.default = import_default;