@interactivethings/scripts 0.0.8 → 2.0.0

package/dist/plugins/tokens-studio/utils.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flattenTokens = exports.formatValues = exports.resolveReferences = exports.deepMerge = exports.isToken = exports.maybeParseToPx = exports.maybeParseToNumber = exports.mapEntries = exports.kebabCase = exports.simplifyValues = void 0;
+const remeda_1 = require("remeda");
+/**
+ * Shared utility functions for tokens-studio transformations
+ */
+/**
+ * Simplifies nested token values by extracting the 'value' property
+ */
+const simplifyValues = (x) => {
+    if (typeof x === "string") {
+        return x;
+    }
+    else if (typeof x === "object" && !!x) {
+        if ("value" in x) {
+            return x.value;
+        }
+        else {
+            return (0, remeda_1.mapValues)(x, exports.simplifyValues);
+        }
+    }
+};
+exports.simplifyValues = simplifyValues;
+/**
+ * Converts space-separated strings to camelCase
+ */
+const kebabCase = (x) => {
+    return x
+        .split(" ")
+        .map((t, i) => {
+        if (i === 0) {
+            return t.toLowerCase();
+        }
+        else {
+            return `${t[0].toUpperCase()}${t.substring(1).toLowerCase()}`;
+        }
+    })
+        .join("");
+};
+exports.kebabCase = kebabCase;
+/**
+ * Maps over object entries with a custom mapper function
+ */
+const mapEntries = (obj, mapper) => {
+    return Object.fromEntries(Object.entries(obj).map(([key, value]) => mapper(key, value)));
+};
+exports.mapEntries = mapEntries;
+/**
+ * Attempts to parse a string or number to a number, returns original if not possible
+ */
+const maybeParseToNumber = (x) => {
+    const parsed = Number(x);
+    if (Number.isNaN(parsed)) {
+        return x;
+    }
+    else {
+        return parsed;
+    }
+};
+exports.maybeParseToNumber = maybeParseToNumber;
+/**
+ * Converts a value to pixels (adds 'px' suffix if it's a number)
+ */
+const maybeParseToPx = (x) => {
+    if (typeof x === "number") {
+        return `${x}px`;
+    }
+    else {
+        return x;
+    }
+};
+exports.maybeParseToPx = maybeParseToPx;
+/**
+ * Type guard to check if an object is a token with value and type properties
+ */
+const isToken = (obj) => {
+    return typeof obj === "object" && "value" in obj && "type" in obj;
+};
+exports.isToken = isToken;
+/**
+ * Deep merge utility for combining token objects
+ */
+const deepMerge = (mergedTokens, tokenData) => {
+    for (const key in tokenData) {
+        if (tokenData.hasOwnProperty(key)) {
+            if (typeof tokenData[key] === "object" &&
+                !Array.isArray(tokenData[key]) &&
+                tokenData[key] !== null) {
+                if (!mergedTokens[key]) {
+                    mergedTokens[key] = {};
+                }
+                (0, exports.deepMerge)(mergedTokens[key], tokenData[key]);
+            }
+            else {
+                mergedTokens[key] = tokenData[key];
+            }
+        }
+    }
+};
+exports.deepMerge = deepMerge;
+/**
+ * Resolves token references (strings like "{path.to.token}") using a value map
+ */
+const resolveReferences = (obj, map) => {
+    const resolveValue = (value) => {
+        if (typeof value === "string" &&
+            value.startsWith("{") &&
+            value.endsWith("}")) {
+            const key = value.slice(1, -1);
+            return map.get(key) ?? value;
+        }
+        return value;
+    };
+    const traverse = (obj, currentPath = []) => {
+        for (const key in obj) {
+            const newPath = [...currentPath, key];
+            if (obj[key] && typeof obj[key] === "object") {
+                const maybeToken = obj[key];
+                if ((0, exports.isToken)(maybeToken)) {
+                    const fullPath = newPath.join(".");
+                    map.set(fullPath, maybeToken.value);
+                    maybeToken.value = resolveValue(maybeToken.value);
+                }
+                else {
+                    traverse(maybeToken, newPath);
+                }
+            }
+        }
+    };
+    traverse(obj);
+};
+exports.resolveReferences = resolveReferences;
+/**
+ * Formats token values by extracting the value property
+ */
+const formatValues = (v) => {
+    return v.value;
+};
+exports.formatValues = formatValues;
+const flattenTokens = (v, depth = 0, transformKey) => {
+    if (typeof v === "object") {
+        if ((0, exports.isToken)(v)) {
+            return (0, exports.formatValues)(v);
+        }
+        return (0, exports.mapEntries)(v, (k, v) => {
+            return [
+                transformKey(k, depth + 1),
+                (0, exports.flattenTokens)(v, depth + 1, transformKey),
+            ];
+        });
+    }
+    return v;
+};
+exports.flattenTokens = flattenTokens;

package/dist/tokens-studio/__tests__/fixtures/invalid-transformer.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Invalid transformer for testing error cases
+ * This transformer does not export a transform function
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function someOtherFunction() {
+    return "not a transformer";
+}
+exports.default = {
+    someOtherFunction,
+};

package/dist/tokens-studio/__tests__/fixtures/test-transformer.js

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Test transformer for tokens-studio CLI tests
+ * This transformer simply wraps the input tokens with metadata
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+function transform(input) {
+    return {
+        source: "test-transformer",
+        metadata: input.metadata,
+        tokens: input.tokenData,
+        processed: true,
+        transformedAt: new Date().toISOString(),
+    };
+}
+exports.default = {
+    transform,
+};

package/dist/tokens-studio/cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * CLI entry point for tokens-studio transformations
+ * Supports different transformer handlers via --handler argument
+ */
+import { ArgumentParser } from "argparse";
+export declare const configParser: (parser: ArgumentParser) => void;
+export declare const run: (parser: ArgumentParser) => Promise<void>;

package/dist/tokens-studio/cli.js

@@ -0,0 +1,119 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * CLI entry point for tokens-studio transformations
+ * Supports different transformer handlers via --handler argument
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = exports.configParser = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_1 = require("../config");
+const utils_1 = require("./utils");
+const require_1 = require("./require");
+const readJsonFile = (filePath) => {
+    return JSON.parse(fs.readFileSync(filePath, "utf-8"));
+};
+const loadTokensFromDirectory = (tokensDir) => {
+    const metadata = readJsonFile(path.join(tokensDir, "$metadata.json"));
+    const mergedTokens = {};
+    metadata.tokenSetOrder.forEach((tokenFile) => {
+        const tokenFilePath = path.join(tokensDir, `${tokenFile}.json`);
+        const tokenData = readJsonFile(tokenFilePath);
+        (0, utils_1.deepMerge)(mergedTokens, tokenData);
+    });
+    return {
+        metadata,
+        tokenData: mergedTokens,
+    };
+};
+const configParser = (parser) => {
+    parser.add_argument("--config", {
+        help: "Path to TypeScript config file (default: looks for ixt.config.ts in current directory)",
+    });
+    const subparsers = parser.add_subparsers({
+        title: "tokens-studio commands",
+        dest: "subcommand",
+        help: "Use 'ixt tokens-studio <subcommand> --help' for more information",
+    });
+    // Transform subcommand
+    const transformParser = subparsers.add_parser("transform", {
+        help: "Transform tokens using a transformer file",
+    });
+    transformParser.add_argument("--handler", {
+        help: "Path to the transformer handler file (e.g., ./my-mui-transform.ts)",
+    });
+    transformParser.add_argument("--input", {
+        help: "Input directory containing token files",
+    });
+    transformParser.add_argument("--output", {
+        help: "Output file path (e.g., theme.json)",
+    });
+};
+exports.configParser = configParser;
+const run = async (args) => {
+    switch (args.subcommand) {
+        case "transform":
+            // Load configuration
+            const config = await (0, config_1.loadConfig)(args.config);
+            // Merge CLI args with config, giving precedence to CLI args
+            const mergedConfig = (0, config_1.mergeConfigWithArgs)(config, {
+                handler: args.handler,
+                input: args.input,
+                output: args.output,
+            }, "tokensStudio");
+            // Validate required configuration
+            (0, config_1.validateRequiredConfig)(mergedConfig, ["handler", "output"]);
+            // Resolve handler path
+            const handlerPath = path.resolve(mergedConfig.handler);
+            if (!fs.existsSync(handlerPath)) {
+                throw new Error(`Handler file not found: ${handlerPath}`);
+            }
+            // Load the transformer module
+            console.log("Requiring handler:", handlerPath);
+            const transformerModule = await (0, require_1.ourRequire)(handlerPath);
+            if (!transformerModule.transform ||
+                typeof transformerModule.transform !== "function") {
+                throw new Error(`Handler file must export a 'transform' function: ${handlerPath}`);
+            }
+            // Load tokens from input directory
+            const inputDir = path.resolve(mergedConfig.input || "./tokens");
+            if (!fs.existsSync(inputDir)) {
+                throw new Error(`Input directory not found: ${inputDir}`);
+            }
+            const transformInput = loadTokensFromDirectory(inputDir);
+            // Apply transformation
+            const result = transformerModule.transform(transformInput);
+            // Write output
+            const outputPath = path.resolve(mergedConfig.output);
+            fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+            console.log(`✅ Transformation complete! Output written to: ${outputPath}`);
+            break;
+        default:
+            throw new Error(`Unknown subcommand: ${args.subcommand}`);
+    }
+};
+exports.run = run;

package/dist/tokens-studio/cli.test.js

@@ -0,0 +1,150 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const argparse_1 = require("argparse");
+const cli_1 = require("./cli");
+const config = __importStar(require("../config"));
+const require_1 = require("./require");
+const testTransformer = __importStar(require("./__tests__/fixtures/test-transformer"));
+// Mock dependencies
+vitest_1.vi.mock("fs");
+vitest_1.vi.mock("../config");
+vitest_1.vi.mock("./utils", () => ({
+    deepMerge: vitest_1.vi.fn((target, source) => {
+        Object.assign(target, source);
+    }),
+}));
+vitest_1.vi.mock("./require", () => ({
+    ourRequire: vitest_1.vi.fn(),
+}));
+(0, vitest_1.describe)("tokens-studio CLI", () => {
+    const mockedFs = vitest_1.vi.mocked(fs);
+    const mockedConfig = vitest_1.vi.mocked(config);
+    // Test fixtures paths
+    const fixturesDir = path.join(__dirname, "__tests__", "fixtures");
+    const testTransformerPath = path.join(fixturesDir, "test-transformer.ts");
+    const tokensDir = path.join(fixturesDir, "tokens");
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.vi.clearAllMocks();
+        // Reset console.log spy
+        vitest_1.vi.spyOn(console, "log").mockImplementation(() => { });
+        // Mock fs.readFileSync to read actual fixture files
+        const originalReadFileSync = require("fs").readFileSync;
+        mockedFs.readFileSync.mockImplementation((filePath, encoding) => {
+            // Use real fs to read fixture files
+            return originalReadFileSync(filePath, encoding);
+        });
+        // Mock fs.writeFileSync
+        mockedFs.writeFileSync.mockImplementation(() => { });
+        // Mock default config functions
+        mockedConfig.loadConfig.mockResolvedValue({
+            tokensStudio: {
+                input: "./tokens",
+            },
+        });
+        mockedConfig.mergeConfigWithArgs.mockReturnValue({
+            input: tokensDir,
+            handler: testTransformerPath,
+            output: "./output.json",
+        });
+        mockedConfig.validateRequiredConfig.mockImplementation(() => { });
+    });
+    (0, vitest_1.afterEach)(() => {
+        vitest_1.vi.restoreAllMocks();
+        // Restore original require if it was mocked
+        if (global.require !== require) {
+            global.require = require;
+        }
+    });
+    (0, vitest_1.describe)("configParser", () => {
+        (0, vitest_1.it)("should configure argument parser with correct subcommands and options", () => {
+            const parser = new argparse_1.ArgumentParser({ description: "Test parser" });
+            const addArgumentSpy = vitest_1.vi.spyOn(parser, "add_argument");
+            const addSubparsersSpy = vitest_1.vi.spyOn(parser, "add_subparsers");
+            (0, cli_1.configParser)(parser);
+            // Check that config argument is added
+            (0, vitest_1.expect)(addArgumentSpy).toHaveBeenCalledWith("--config", {
+                help: "Path to TypeScript config file (default: looks for ixt.config.ts in current directory)",
+            });
+            // Check that subparsers are added
+            (0, vitest_1.expect)(addSubparsersSpy).toHaveBeenCalledWith({
+                title: "tokens-studio commands",
+                dest: "subcommand",
+                help: "Use 'ixt tokens-studio <subcommand> --help' for more information",
+            });
+        });
+    });
+    (0, vitest_1.describe)("run function", () => {
+        (0, vitest_1.describe)("transform subcommand", () => {
+            (0, vitest_1.it)("should call transformer with correct token data structure", async () => {
+                mockedFs.existsSync.mockReturnValue(true);
+                const mockTransform = vitest_1.vi.fn().mockReturnValue({ transformed: true });
+                // Setup require to return mocked transformer based on actual fixture
+                vitest_1.vi.mocked(require_1.ourRequire).mockImplementation(async (id) => {
+                    if (id === testTransformerPath) {
+                        return { transform: mockTransform };
+                    }
+                    return testTransformer.default;
+                });
+                const args = {
+                    subcommand: "transform",
+                    handler: testTransformerPath,
+                    input: tokensDir,
+                    output: "./output.json",
+                };
+                await (0, cli_1.run)(args);
+                // Verify transformer was called with correct structure
+                (0, vitest_1.expect)(mockTransform).toHaveBeenCalledWith({
+                    metadata: { tokenSetOrder: ["base", "semantic"] },
+                    tokenData: vitest_1.expect.objectContaining({
+                        colors: vitest_1.expect.objectContaining({}),
+                        spacing: vitest_1.expect.objectContaining({
+                            xs: { value: "4px", type: "spacing" },
+                        }),
+                        components: vitest_1.expect.objectContaining({
+                            button: {
+                                padding: { value: "{spacing.sm}", type: "spacing" },
+                            },
+                        }),
+                    }),
+                });
+            });
+            (0, vitest_1.it)("should handle config validation errors", async () => {
+                mockedConfig.validateRequiredConfig.mockImplementation(() => {
+                    throw new Error("Missing required configuration: handler");
+                });
+                const args = {
+                    subcommand: "transform",
+                    input: tokensDir,
+                    output: "./output.json",
+                };
+                await (0, vitest_1.expect)((0, cli_1.run)(args)).rejects.toThrow("Missing required configuration: handler");
+            });
+        });
+    });
+});

package/dist/tokens-studio/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Tokens Studio module for @interactivethings/scripts
+ *
+ * This module provides utilities and transformers for working with
+ * tokens exported from Tokens Studio (Figma plugin).
+ */
+export { simplifyValues, kebabCase, mapEntries, maybeParseToNumber, maybeParseToPx, isToken, deepMerge, resolveReferences, formatValues, flattenTokens, } from "./utils";
+export interface TransformInput {
+    metadata: {
+        tokenSetOrder: string[];
+    };
+    tokenData: any;
+}
+export * as cli from "./cli";

package/dist/tokens-studio/index.js

@@ -0,0 +1,46 @@
+"use strict";
+/**
+ * Tokens Studio module for @interactivethings/scripts
+ *
+ * This module provides utilities and transformers for working with
+ * tokens exported from Tokens Studio (Figma plugin).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cli = exports.flattenTokens = exports.formatValues = exports.resolveReferences = exports.deepMerge = exports.isToken = exports.maybeParseToPx = exports.maybeParseToNumber = exports.mapEntries = exports.kebabCase = exports.simplifyValues = void 0;
+// Export all utility functions
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "simplifyValues", { enumerable: true, get: function () { return utils_1.simplifyValues; } });
+Object.defineProperty(exports, "kebabCase", { enumerable: true, get: function () { return utils_1.kebabCase; } });
+Object.defineProperty(exports, "mapEntries", { enumerable: true, get: function () { return utils_1.mapEntries; } });
+Object.defineProperty(exports, "maybeParseToNumber", { enumerable: true, get: function () { return utils_1.maybeParseToNumber; } });
+Object.defineProperty(exports, "maybeParseToPx", { enumerable: true, get: function () { return utils_1.maybeParseToPx; } });
+Object.defineProperty(exports, "isToken", { enumerable: true, get: function () { return utils_1.isToken; } });
+Object.defineProperty(exports, "deepMerge", { enumerable: true, get: function () { return utils_1.deepMerge; } });
+Object.defineProperty(exports, "resolveReferences", { enumerable: true, get: function () { return utils_1.resolveReferences; } });
+Object.defineProperty(exports, "formatValues", { enumerable: true, get: function () { return utils_1.formatValues; } });
+Object.defineProperty(exports, "flattenTokens", { enumerable: true, get: function () { return utils_1.flattenTokens; } });
+// Export the CLI module (for internal use)
+exports.cli = __importStar(require("./cli"));