@tokens-studio/tokenscript-schemas 0.0.11 → 0.0.12

package/src/bundler/types.ts

@@ -0,0 +1,93 @@
+/**
+ * Types for schema bundler
+ */
+
+export interface SchemaFile {
+  path: string;
+  content: string;
+}
+
+export interface SchemaBundle {
+  slug: string;
+  name: string;
+  type: "type" | "function";
+  version: string;
+  schema?: unknown;
+  scripts: Record<string, string>;
+  metadata: {
+    id: string;
+    description: string;
+    contentType: string | null;
+    originalVersion: string;
+  };
+}
+
+// Color specification types matching typescript-interpreter format
+export interface ScriptBlock {
+  type: string;
+  script: string;
+}
+
+export interface Initializer {
+  title?: string;
+  keyword: string;
+  description?: string;
+  schema?: unknown;
+  script: ScriptBlock;
+}
+
+export interface Conversion {
+  source: string;
+  target: string;
+  description?: string;
+  lossless: boolean;
+  script: ScriptBlock;
+}
+
+export interface SpecProperty {
+  type: "number" | "string" | "color";
+}
+
+export interface SpecSchema {
+  type: "object";
+  properties: Record<string, SpecProperty>;
+  required?: string[];
+  order?: string[];
+  additionalProperties?: boolean;
+}
+
+export interface ColorSpecification {
+  name: string;
+  type: "color";
+  description?: string;
+  schema?: SpecSchema;
+  initializers: Initializer[];
+  conversions: Conversion[];
+  slug?: string; // Added for bundling purposes
+}
+
+export interface FunctionSpecification {
+  name: string;
+  type: "function";
+  input?: {
+    type: "object";
+    properties?: Record<string, unknown>;
+  };
+  script: ScriptBlock;
+  keyword: string;
+  description?: string;
+  requirements?: string[];
+  slug?: string; // Added for bundling purposes
+}
+
+export type SchemaSpecification = ColorSpecification | FunctionSpecification;
+
+export interface BundledRegistry {
+  version: string;
+  types: ColorSpecification[];
+  functions: FunctionSpecification[];
+  metadata: {
+    generatedAt: string;
+    totalSchemas: number;
+  };
+}

package/src/bundler/utils.ts

@@ -0,0 +1,74 @@
+/**
+ * Bundler utilities
+ */
+
+import { readdir, readFile, stat } from "node:fs/promises";
+import { join } from "node:path";
+
+/**
+ * Check if a path is a directory
+ */
+export async function isDirectory(path: string): Promise<boolean> {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get all subdirectories in a directory
+ */
+export async function getSubdirectories(dir: string): Promise<string[]> {
+  const entries = await readdir(dir);
+  const subdirs: string[] = [];
+
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    if (await isDirectory(fullPath)) {
+      subdirs.push(entry);
+    }
+  }
+
+  return subdirs;
+}
+
+/**
+ * Read all tokenscript files from a schema directory
+ */
+export async function readTokenScriptFiles(schemaDir: string): Promise<Record<string, string>> {
+  const entries = await readdir(schemaDir);
+  const scripts: Record<string, string> = {};
+
+  for (const entry of entries) {
+    if (entry.endsWith(".tokenscript")) {
+      const filePath = join(schemaDir, entry);
+      const content = await readFile(filePath, "utf-8");
+      const scriptName = entry.replace(".tokenscript", "");
+      scripts[scriptName] = content;
+    }
+  }
+
+  return scripts;
+}
+
+/**
+ * Read and parse a JSON file
+ */
+export async function readJsonFile<T = unknown>(filePath: string): Promise<T> {
+  const content = await readFile(filePath, "utf-8");
+  return JSON.parse(content) as T;
+}
+
+/**
+ * Check if a file exists
+ */
+export async function fileExists(filePath: string): Promise<boolean> {
+  try {
+    await stat(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/cli/commands/bundle.integration.test.ts

@@ -0,0 +1,153 @@
+import { unlink, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { afterAll, describe, expect, it, vi } from "vitest";
+import { bundleSchemas } from "./bundle.js";
+
+// Mock ulog to silence logs during tests
+vi.mock("ulog", () => {
+  const mockLogger = () => {};
+  mockLogger.error = () => {};
+  mockLogger.warn = () => {};
+  mockLogger.info = () => {};
+  mockLogger.log = () => {};
+  mockLogger.debug = () => {};
+  mockLogger.trace = () => {};
+
+  return {
+    default: () => mockLogger,
+  };
+});
+
+describe("Bundle Integration Test", () => {
+  const testFiles: string[] = [];
+
+  const createTestFile = async (name: string, content: string) => {
+    const path = join(process.cwd(), `test-bundle-${name}-${Date.now()}.js`);
+    testFiles.push(path);
+    await writeFile(path, content, "utf-8");
+    return path;
+  };
+
+  afterAll(async () => {
+    // Clean up all test files
+    await Promise.all(
+      testFiles.map(async (file) => {
+        try {
+          await unlink(file);
+        } catch {
+          // Ignore if file doesn't exist
+        }
+      }),
+    );
+  });
+
+  it("should create a valid bundle file that can be loaded and used", async () => {
+    // Step 1: Bundle schemas
+    const result = await bundleSchemas(["rgb-color", "function:invert"]);
+
+    expect(result.output).toBeTruthy();
+    expect(result.metadata.resolvedDependencies).toContain("rgb-color");
+    expect(result.metadata.resolvedDependencies).toContain("invert");
+
+    // Step 2: Write and import the bundle
+    const testFile = await createTestFile("basic", result.output);
+    const fileUrl = `${pathToFileURL(testFile).href}?t=${Date.now()}`;
+    const bundle = await import(fileUrl);
+
+    // Step 3: Verify exports exist
+    expect(bundle.SCHEMAS).toBeDefined();
+    expect(Array.isArray(bundle.SCHEMAS)).toBe(true);
+    expect(bundle.makeConfig).toBeDefined();
+    expect(typeof bundle.makeConfig).toBe("function");
+
+    // Step 4: Verify SCHEMAS structure
+    expect(bundle.SCHEMAS.length).toBeGreaterThan(0);
+
+    const firstSchema = bundle.SCHEMAS[0];
+    expect(firstSchema.uri).toBeDefined();
+    expect(firstSchema.schema).toBeDefined();
+    expect(typeof firstSchema.uri).toBe("string");
+    expect(typeof firstSchema.schema).toBe("object");
+
+    // Step 5: Create config using the helper
+    const config = bundle.makeConfig();
+    expect(config).toBeDefined();
+
+    // Step 6: Verify config has the schemas registered
+    // The config should be an instance of Config from @tokens-studio/tokenscript-interpreter
+    expect(config.constructor.name).toBe("Config");
+
+    // Step 7: Verify we can find our schemas in the config
+    const rgbColorUri = bundle.SCHEMAS.find((s: any) => s.uri.includes("rgb-color"))?.uri;
+    const invertUri = bundle.SCHEMAS.find((s: any) => s.uri.includes("/function/invert/"))?.uri;
+
+    expect(rgbColorUri).toBeDefined();
+    expect(invertUri).toBeDefined();
+  });
+
+  it("should bundle function with dependencies and create working config", async () => {
+    // Bundle a function that has dependencies
+    const result = await bundleSchemas(["function:adjust_chroma"]);
+
+    expect(result.metadata.resolvedDependencies).toContain("adjust_chroma");
+    expect(result.metadata.resolvedDependencies).toContain("srgb-color");
+    expect(result.metadata.resolvedDependencies).toContain("oklch-color");
+
+    // Write and import the bundle
+    const testFile = await createTestFile("function-deps", result.output);
+    const fileUrl = `${pathToFileURL(testFile).href}?t=${Date.now()}`;
+    const bundle = await import(fileUrl);
+
+    // Verify key dependencies are in the bundle
+    // With includeColorTypeDependencies, this pulls in all conversion dependencies
+    expect(bundle.SCHEMAS.length).toBeGreaterThanOrEqual(3);
+
+    const schemaUris = bundle.SCHEMAS.map((s: any) => s.uri);
+    expect(schemaUris.some((uri: string) => uri.includes("adjust_chroma"))).toBe(true);
+    expect(schemaUris.some((uri: string) => uri.includes("srgb-color"))).toBe(true);
+    expect(schemaUris.some((uri: string) => uri.includes("oklch-color"))).toBe(true);
+
+    // Create config and verify it works
+    const config = bundle.makeConfig();
+    expect(config).toBeDefined();
+  });
+
+  it("should handle multiple requested schemas correctly", async () => {
+    const result = await bundleSchemas(["rgb-color", "hex-color", "hsl-color"]);
+
+    // Write and import the bundle
+    const testFile = await createTestFile("multiple", result.output);
+    const fileUrl = `${pathToFileURL(testFile).href}?t=${Date.now()}`;
+    const bundle = await import(fileUrl);
+
+    // Should have the requested schemas plus their conversion dependencies
+    // With includeColorTypeDependencies, this pulls in all conversion dependencies
+    expect(bundle.SCHEMAS.length).toBeGreaterThanOrEqual(3);
+
+    const schemaUris = bundle.SCHEMAS.map((s: any) => s.uri);
+    expect(schemaUris.some((uri: string) => uri.includes("rgb-color"))).toBe(true);
+    expect(schemaUris.some((uri: string) => uri.includes("hex-color"))).toBe(true);
+    expect(schemaUris.some((uri: string) => uri.includes("hsl-color"))).toBe(true);
+  });
+
+  it("should generate valid JavaScript with proper imports", async () => {
+    const result = await bundleSchemas(["rgb-color"]);
+
+    // Verify the output has the expected structure
+    expect(result.output).toContain(
+      'import { Config } from "@tokens-studio/tokenscript-interpreter"',
+    );
+    expect(result.output).toContain("export const SCHEMAS = [");
+    expect(result.output).toContain("export function makeConfig()");
+    expect(result.output).toContain("return new Config().registerSchemas(SCHEMAS)");
+    expect(result.output).toContain("Auto-generated by @tokens-studio/tokenscript-schemas");
+
+    // Write and verify it's valid JavaScript by importing it
+    const testFile = await createTestFile("valid-js", result.output);
+    const fileUrl = `${pathToFileURL(testFile).href}?t=${Date.now()}`;
+
+    // This will throw if the JavaScript is invalid
+    await expect(import(fileUrl)).resolves.toBeDefined();
+  });
+});

package/src/cli/commands/bundle.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it, vi } from "vitest";
+import { bundleSchemas } from "./bundle.js";
+
+// Mock ulog to silence logs during tests
+vi.mock("ulog", () => {
+  const mockLogger = () => {};
+  mockLogger.error = () => {};
+  mockLogger.warn = () => {};
+  mockLogger.info = () => {};
+  mockLogger.log = () => {};
+  mockLogger.debug = () => {};
+  mockLogger.trace = () => {};
+
+  return {
+    default: () => mockLogger,
+  };
+});
+
+describe("Bundle Command", () => {
+  it("should bundle schemas and return output", async () => {
+    const result = await bundleSchemas(["hex-color"]);
+
+    expect(result.output).toContain("export const SCHEMAS");
+    expect(result.output).toContain("export function makeConfig()");
+    expect(result.output).toContain("hex-color");
+    expect(result.metadata.requestedSchemas).toEqual(["hex-color"]);
+  });
+
+  it("should bundle multiple schemas with dependencies", async () => {
+    const result = await bundleSchemas(["function:adjust_chroma"]);
+
+    expect(result.output).toContain("SCHEMAS");
+    expect(result.metadata.requestedSchemas).toEqual(["function:adjust_chroma"]);
+
+    // adjust_chroma requires srgb-color and oklch-color
+    // With includeColorTypeDependencies, this pulls in all conversion dependencies
+    expect(result.metadata.resolvedDependencies.length).toBeGreaterThanOrEqual(3);
+    expect(result.metadata.resolvedDependencies).toContain("adjust_chroma");
+    expect(result.metadata.resolvedDependencies).toContain("srgb-color");
+    expect(result.metadata.resolvedDependencies).toContain("oklch-color");
+  });
+
+  it("should bundle function schemas", async () => {
+    const result = await bundleSchemas(["function:invert"]);
+
+    expect(result.output).toContain("SCHEMAS");
+    expect(result.output).toContain("/function/invert/");
+    expect(result.metadata.requestedSchemas).toEqual(["function:invert"]);
+  });
+
+  it("should include auto-generated header comment", async () => {
+    const result = await bundleSchemas(["hex-color"]);
+
+    expect(result.output).toContain("Auto-generated by @tokens-studio/tokenscript-schemas");
+    expect(result.output).toContain("Generated:");
+  });
+});

package/src/cli/commands/bundle.ts

@@ -0,0 +1,240 @@
+/**
+ * Bundle command - Bundle schemas into a JS file
+ */
+
+/// <reference types="../../../types/ulog" />
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import anylogger from "ulog";
+import { bundleSelectiveSchemas } from "@/bundler/selective-bundler.js";
+import { type BundleConfig, validateBundleConfig } from "@/cli/config-schema.js";
+import { generateOutput } from "@/cli/output-generator.js";
+import { isSome } from "@/utils/type.js";
+
+const log = anylogger("bundle");
+
+export interface BundleOptions {
+  config?: string;
+  output?: string;
+  dryRun?: boolean;
+}
+
+/**
+ * Load config from file
+ */
+async function loadConfig(configPath: string): Promise<BundleConfig> {
+  try {
+    const content = await readFile(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return validateBundleConfig(parsed);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Format dependency tree for display
+ */
+function formatDependencyTree(
+  tree: Map<string, import("@/bundler/schema-dependency-resolver.js").DependencyNode>,
+  requestedSchemas: string[],
+): string {
+  const lines: string[] = [];
+  const visited = new Set<string>();
+
+  lines.push("Dependency tree:");
+  lines.push("");
+
+  // Helper to format a node
+  const formatNode = (key: string, indent: string = "", isLast: boolean = true) => {
+    if (visited.has(key)) {
+      return;
+    }
+    visited.add(key);
+
+    const node = tree.get(key);
+    if (!node) return;
+
+    const prefix = indent + (isLast ? "└── " : "├── ");
+    const label = `${node.type}:${node.slug}`;
+    lines.push(prefix + label);
+
+    if (node.dependencies.length > 0) {
+      const childIndent = indent + (isLast ? "    " : "│   ");
+      node.dependencies.forEach((dep, idx) => {
+        const isLastChild = idx === node.dependencies.length - 1;
+        const childKey = dep;
+
+        if (visited.has(childKey)) {
+          const childPrefix = childIndent + (isLastChild ? "└── " : "├── ");
+          lines.push(`${childPrefix + childKey} (already visited)`);
+        } else {
+          formatNode(childKey, childIndent, isLastChild);
+        }
+      });
+    }
+  };
+
+  // Format requested schemas
+  requestedSchemas.forEach((schema, idx) => {
+    // Try to find the schema with different type prefixes
+    const typeKey = `type:${schema}`;
+    const funcKey = `function:${schema}`;
+    const key = tree.has(typeKey) ? typeKey : tree.has(funcKey) ? funcKey : schema;
+
+    formatNode(key, "", idx === requestedSchemas.length - 1);
+  });
+
+  return lines.join("\n");
+}
+
+/**
+ * Format bundle result for dry-run display
+ */
+function formatDryRunOutput(schemas: string[], resolvedDependencies: string[]): string {
+  const lines: string[] = [];
+
+  lines.push("Bundle preview:");
+  lines.push("");
+  lines.push(`Requested schemas: ${schemas.join(", ")}`);
+  lines.push(`Total schemas (with dependencies): ${resolvedDependencies.length}`);
+  lines.push("");
+  lines.push("Schemas to be bundled:");
+
+  for (const schema of resolvedDependencies.sort()) {
+    lines.push(`  - ${schema}`);
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Find the schemas directory - works for both development/tests and installed package
+ */
+function findSchemasDir(): string {
+  const __filename = fileURLToPath(import.meta.url);
+  const __dirname = dirname(__filename);
+
+  // From compiled dist/cli/index.js (bundled) to src/schemas
+  const fromDist = join(__dirname, "../../src/schemas");
+
+  // From source src/cli/commands/bundle.ts to src/schemas (for tests/dev)
+  const fromSource = join(__dirname, "../../schemas");
+
+  // Try to detect which one exists
+  try {
+    const fs = require("node:fs");
+    if (fs.existsSync(fromDist)) {
+      return fromDist;
+    }
+    if (fs.existsSync(fromSource)) {
+      return fromSource;
+    }
+  } catch {
+    // If fs checks fail, default to dist structure
+  }
+
+  // Default to dist structure (for installed package)
+  return fromDist;
+}
+
+/**
+ * Core bundle logic (testable)
+ */
+export async function bundleSchemas(
+  schemas: string[],
+  schemasDir?: string,
+): Promise<{
+  output: string;
+  metadata: any;
+  dependencyTree: Map<string, import("@/bundler/schema-dependency-resolver.js").DependencyNode>;
+}> {
+  // Use provided schemasDir or auto-detect
+  const resolvedSchemasDir = schemasDir || findSchemasDir();
+
+  log.info("Bundling schemas:", schemas);
+  log.debug("Schemas directory:", resolvedSchemasDir);
+
+  // Bundle schemas with dependencies
+  const result = await bundleSelectiveSchemas({
+    schemas,
+    schemasDir: resolvedSchemasDir,
+  });
+
+  log.info(
+    `Resolved ${result.metadata.resolvedDependencies.length} schemas (including dependencies)`,
+  );
+
+  // Generate output
+  const output = generateOutput({
+    schemas: result.schemas,
+    includeHelper: true,
+  });
+
+  return {
+    output,
+    metadata: result.metadata,
+    dependencyTree: result.dependencyTree,
+  };
+}
+
+/**
+ * CLI action handler for bundle command
+ */
+export async function handleBundleCommand(
+  schemas: string[],
+  options: BundleOptions = {},
+): Promise<void> {
+  try {
+    // Load config if provided
+    let configSchemas: string[] = schemas;
+    let outputPath = options.output || "./tokenscript-schemas.js";
+
+    if (isSome(options.config)) {
+      log.info(`Loading config from ${options.config}`);
+      const config = await loadConfig(options.config);
+      configSchemas = config.schemas;
+      if (config.output) {
+        outputPath = config.output;
+      }
+    }
+
+    // Validate we have schemas
+    if (!configSchemas || configSchemas.length === 0) {
+      throw new Error("No schemas specified. Provide schemas as arguments or via --config");
+    }
+
+    // Bundle schemas
+    const { output, metadata, dependencyTree } = await bundleSchemas(configSchemas);
+
+    // Show dependency tree
+    console.log("");
+    console.log(formatDependencyTree(dependencyTree, metadata.requestedSchemas));
+    console.log("");
+
+    // Dry run - just show what would be bundled
+    if (options.dryRun) {
+      const preview = formatDryRunOutput(metadata.requestedSchemas, metadata.resolvedDependencies);
+      console.log(preview);
+      return;
+    }
+
+    // Write output file
+    await mkdir(dirname(outputPath), { recursive: true });
+    await writeFile(outputPath, output, "utf-8");
+
+    log.info(`Successfully bundled ${metadata.resolvedDependencies.length} schemas`);
+    log.info(`Output written to: ${outputPath}`);
+
+    // Summary
+    console.log(`✓ Bundled ${metadata.resolvedDependencies.length} schemas → ${outputPath}`);
+  } catch (error) {
+    log.error("Bundle failed:", error);
+    throw error;
+  }
+}