@tokens-studio/tokenscript-schemas 0.0.10

package/dist/cli/index.cjs

@@ -0,0 +1,652 @@
+#!/usr/bin/env node
+'use strict';
+
+var cac = require('cac');
+var ulog = require('ulog');
+var promises = require('fs/promises');
+var path = require('path');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var cac__default = /*#__PURE__*/_interopDefault(cac);
+var ulog__default = /*#__PURE__*/_interopDefault(ulog);
+
+async function bundleSchemaFromDirectory(schemaDir, options) {
+  const schemaJsonPath = path.join(schemaDir, "schema.json");
+  const schemaContent = await promises.readFile(schemaJsonPath, "utf-8");
+  const schema = JSON.parse(schemaContent);
+  if (schema.type === "function") {
+    return await inlineFunctionScriptReferences(
+      schemaDir,
+      schema,
+      options
+    );
+  } else {
+    return await inlineColorScriptReferences(schemaDir, schema, options);
+  }
+}
+async function inlineColorScriptReferences(schemaDir, schema, options) {
+  const result = JSON.parse(JSON.stringify(schema));
+  for (const initializer of result.initializers) {
+    if (initializer.script.script.startsWith("./")) {
+      const scriptPath = path.join(schemaDir, initializer.script.script.slice(2));
+      const scriptContent = await promises.readFile(scriptPath, "utf-8");
+      initializer.script.script = scriptContent.trim();
+    }
+    if (options?.baseUrl) {
+      initializer.script.type = addBaseUrl(initializer.script.type, options.baseUrl);
+    }
+  }
+  for (const conversion of result.conversions) {
+    if (conversion.script.script.startsWith("./")) {
+      const scriptPath = path.join(schemaDir, conversion.script.script.slice(2));
+      const scriptContent = await promises.readFile(scriptPath, "utf-8");
+      conversion.script.script = scriptContent.trim();
+    }
+    if (options?.baseUrl) {
+      conversion.script.type = addBaseUrl(conversion.script.type, options.baseUrl);
+      if (conversion.source !== "$self") {
+        conversion.source = addBaseUrl(conversion.source, options.baseUrl);
+      }
+      if (conversion.target !== "$self") {
+        conversion.target = addBaseUrl(conversion.target, options.baseUrl);
+      }
+    }
+  }
+  return result;
+}
+async function inlineFunctionScriptReferences(schemaDir, schema, options) {
+  const result = JSON.parse(JSON.stringify(schema));
+  if (result.script.script.startsWith("./")) {
+    const scriptPath = path.join(schemaDir, result.script.script.slice(2));
+    const scriptContent = await promises.readFile(scriptPath, "utf-8");
+    result.script.script = scriptContent.trim();
+  }
+  if (options?.baseUrl) {
+    result.script.type = addBaseUrl(result.script.type, options.baseUrl);
+    if (result.requirements) {
+      const baseUrl = options.baseUrl;
+      result.requirements = result.requirements.map((req) => addBaseUrl(req, baseUrl));
+    }
+  }
+  return result;
+}
+function addBaseUrl(uri, baseUrl) {
+  if (uri.includes("://")) {
+    return uri;
+  }
+  if (uri.startsWith("/")) {
+    const cleanBaseUrl = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+    return `${cleanBaseUrl}${uri}`;
+  }
+  return uri;
+}
+var LOG_LEVELS = {
+  error: 1,
+  warn: 2,
+  info: 3,
+  log: 4,
+  debug: 5
+};
+var log = ulog__default.default("schema-registry");
+var logLevel = process.env.LOG_LEVEL || "error";
+log.level = LOG_LEVELS[logLevel] || LOG_LEVELS.error;
+
+// src/utils/type.ts
+var isSome = (v) => {
+  return v != null;
+};
+
+// src/utils/schema-uri.ts
+function safeParseInt(value) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isNaN(parsed) ? null : parsed;
+}
+function parseSemverFromString(versionString) {
+  const parts = versionString.split(".");
+  const numbers = [];
+  for (const part of parts) {
+    const num = safeParseInt(part);
+    if (num === null) return null;
+    numbers.push(num);
+  }
+  if (numbers.length !== parts.length) return null;
+  if (numbers.length === 3) {
+    return { major: numbers[0], minor: numbers[1], patch: numbers[2] };
+  }
+  if (numbers.length === 2) {
+    return { major: numbers[0], minor: numbers[1] };
+  }
+  if (numbers.length === 1) {
+    return { major: numbers[0] };
+  }
+  return null;
+}
+function parseVersionString(versionString) {
+  return versionString === "latest" ? "latest" : parseSemverFromString(versionString);
+}
+function parseSchemaUri(uri) {
+  let baseUrl = "";
+  let pathname = uri;
+  try {
+    const url = new URL(uri);
+    baseUrl = `${url.protocol}//${url.host}`;
+    pathname = url.pathname;
+  } catch {
+    if (uri.includes("://")) {
+      return null;
+    }
+    pathname = uri;
+  }
+  const pathParts = pathname.split("/").filter((part) => part !== "");
+  if (pathParts.length < 5) {
+    return null;
+  }
+  if (pathParts[0] !== "api" || !pathParts[1].startsWith("v")) {
+    return null;
+  }
+  const category = pathParts[2];
+  if (category !== "schema" && category !== "core" && category !== "function") {
+    return null;
+  }
+  const name = pathParts[3];
+  const version = parseVersionString(pathParts[4]);
+  return {
+    baseUrl,
+    category,
+    name,
+    version
+  };
+}
+function extractSchemaName(uri) {
+  const components = parseSchemaUri(uri);
+  return components?.name || null;
+}
+
+// src/bundler/schema-dependency-resolver.ts
+function extractRequirements(spec, options = {}) {
+  const requirements = [];
+  if (spec.type === "function") {
+    const funcSpec = spec;
+    if (funcSpec.requirements) {
+      requirements.push(...funcSpec.requirements);
+    }
+  } else if (spec.type === "color" && options.includeColorTypeDependencies) {
+    const colorSpec = spec;
+    for (const conversion of colorSpec.conversions || []) {
+      if (conversion.source !== "$self") {
+        requirements.push(conversion.source);
+      }
+      if (conversion.target !== "$self") {
+        requirements.push(conversion.target);
+      }
+    }
+  }
+  return requirements;
+}
+function resolveSchemaReference(uriOrName) {
+  const components = parseSchemaUri(uriOrName);
+  if (components) {
+    const type = components.category === "function" ? "function" : "type";
+    return {
+      slug: components.name,
+      type,
+      uri: uriOrName
+    };
+  }
+  const extractedName = extractSchemaName(uriOrName);
+  if (extractedName) {
+    return {
+      slug: extractedName,
+      type: "type",
+      // Default to type if we can't determine
+      uri: uriOrName
+    };
+  }
+  if (uriOrName && !uriOrName.includes("/")) {
+    return {
+      slug: uriOrName,
+      type: "type",
+      // Default to type
+      uri: ""
+      // No URI, just a slug
+    };
+  }
+  return null;
+}
+async function collectRequiredSchemas(slugOrUri, type, options = {}) {
+  const { baseUrl, schemasDir, ...extractOptions } = options;
+  const visited = /* @__PURE__ */ new Set();
+  const typeSchemas = /* @__PURE__ */ new Set();
+  const functionSchemas = /* @__PURE__ */ new Set();
+  async function traverse(currentSlugOrUri, currentType) {
+    const ref = resolveSchemaReference(currentSlugOrUri);
+    if (!ref) {
+      log.warn(`Could not resolve schema reference: ${currentSlugOrUri}`);
+      return;
+    }
+    const effectiveType = currentType || ref.type;
+    const slug = ref.slug;
+    const key = `${effectiveType}:${slug}`;
+    if (visited.has(key)) {
+      return;
+    }
+    visited.add(key);
+    let spec;
+    try {
+      const categoryDir = effectiveType === "type" ? "types" : "functions";
+      const resolvedSchemasDir = schemasDir || process.env.SCHEMAS_DIR || path.join(process.cwd(), "src/schemas");
+      const schemaDir = path.join(resolvedSchemasDir, categoryDir, slug);
+      spec = await bundleSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : void 0);
+    } catch (error) {
+      log.warn(`Failed to load schema ${slug} (${effectiveType}):`, error);
+      return;
+    }
+    const requirements = extractRequirements(spec, extractOptions);
+    for (const reqUri of requirements) {
+      const reqRef = resolveSchemaReference(reqUri);
+      if (reqRef) {
+        if (reqRef.type === "function") {
+          functionSchemas.add(reqRef.slug);
+        } else {
+          typeSchemas.add(reqRef.slug);
+        }
+        await traverse(reqUri, reqRef.type);
+      }
+    }
+  }
+  await traverse(slugOrUri, type);
+  return {
+    types: Array.from(typeSchemas),
+    functions: Array.from(functionSchemas)
+  };
+}
+async function collectRequiredSchemasForList(schemas, options = {}) {
+  const allTypes = /* @__PURE__ */ new Set();
+  const allFunctions = /* @__PURE__ */ new Set();
+  for (const schema of schemas) {
+    const deps = await collectRequiredSchemas(schema.slug, schema.type, options);
+    if (schema.type === "function") {
+      allFunctions.add(schema.slug);
+    } else {
+      allTypes.add(schema.slug);
+    }
+    for (const t of deps.types) {
+      allTypes.add(t);
+    }
+    for (const f of deps.functions) {
+      allFunctions.add(f);
+    }
+  }
+  return {
+    types: Array.from(allTypes),
+    functions: Array.from(allFunctions)
+  };
+}
+async function collectDependencyTree(schemas, options = {}) {
+  const { baseUrl, schemasDir, ...extractOptions } = options;
+  const tree = /* @__PURE__ */ new Map();
+  for (const schema of schemas) {
+    const categoryDir = schema.type === "type" ? "types" : "functions";
+    const resolvedSchemasDir = schemasDir || process.env.SCHEMAS_DIR || path.join(process.cwd(), "src/schemas");
+    const schemaDir = path.join(resolvedSchemasDir, categoryDir, schema.slug);
+    try {
+      const spec = await bundleSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : void 0);
+      const requirements = extractRequirements(spec, extractOptions);
+      const dependencySlugs = requirements.map((uri) => {
+        const ref = resolveSchemaReference(uri);
+        return ref ? `${ref.type}:${ref.slug}` : uri;
+      });
+      const key = `${schema.type}:${schema.slug}`;
+      tree.set(key, {
+        slug: schema.slug,
+        type: schema.type,
+        dependencies: dependencySlugs
+      });
+    } catch (error) {
+      log.warn(`Failed to load schema ${schema.slug} (${schema.type}):`, error);
+    }
+  }
+  return tree;
+}
+
+// src/bundler/selective-bundler.ts
+async function detectSchemaType(slug, schemasDir) {
+  const typeDir = path.join(schemasDir, "types", slug);
+  const functionDir = path.join(schemasDir, "functions", slug);
+  try {
+    await promises.access(typeDir);
+    return "type";
+  } catch {
+  }
+  try {
+    await promises.access(functionDir);
+    return "function";
+  } catch {
+  }
+  return null;
+}
+async function bundleSelectiveSchemas(options) {
+  const schemasDir = options.schemasDir || path.join(process.cwd(), "src/schemas");
+  const baseUrl = options.baseUrl || "https://schema.tokenscript.dev.gcp.tokens.studio";
+  const parsedSchemas = await Promise.all(
+    options.schemas.map(async (slug) => {
+      if (slug.includes(":")) {
+        const [type, name] = slug.split(":");
+        return {
+          slug: name,
+          type: type === "function" ? "function" : "type"
+        };
+      }
+      const detectedType = await detectSchemaType(slug, schemasDir);
+      if (detectedType === null) {
+        throw new Error(
+          `Schema '${slug}' not found in types or functions directories. Use 'function:${slug}' or 'type:${slug}' prefix to be explicit.`
+        );
+      }
+      return { slug, type: detectedType };
+    })
+  );
+  const deps = await collectRequiredSchemasForList(parsedSchemas, {
+    baseUrl,
+    schemasDir,
+    includeColorTypeDependencies: true
+  });
+  const allParsedSchemas = [
+    ...deps.types.map((slug) => ({ slug, type: "type" })),
+    ...deps.functions.map((slug) => ({ slug, type: "function" }))
+  ];
+  const dependencyTree = await collectDependencyTree(allParsedSchemas, {
+    baseUrl,
+    schemasDir,
+    includeColorTypeDependencies: true
+  });
+  const allSchemas = [.../* @__PURE__ */ new Set([...deps.types, ...deps.functions])];
+  const bundledSchemas = [];
+  for (const typeSlug of deps.types) {
+    const schemaDir = path.join(schemasDir, "types", typeSlug);
+    const bundled = await bundleSchemaFromDirectory(schemaDir, { baseUrl });
+    if (bundled.type === "color") {
+      const uri = `${baseUrl}/api/v1/core/${typeSlug}/0/`;
+      bundledSchemas.push({
+        uri,
+        schema: bundled
+      });
+    }
+  }
+  for (const funcSlug of deps.functions) {
+    const schemaDir = path.join(schemasDir, "functions", funcSlug);
+    const bundled = await bundleSchemaFromDirectory(schemaDir, { baseUrl });
+    if (bundled.type === "function") {
+      const uri = `${baseUrl}/api/v1/function/${funcSlug}/0/`;
+      bundledSchemas.push({
+        uri,
+        schema: bundled
+      });
+    }
+  }
+  return {
+    schemas: bundledSchemas,
+    metadata: {
+      requestedSchemas: options.schemas,
+      resolvedDependencies: allSchemas,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    dependencyTree
+  };
+}
+
+// src/cli/config-schema.ts
+function validateBundleConfig(data) {
+  if (typeof data !== "object" || data === null) {
+    throw new Error("Config must be an object");
+  }
+  const config = data;
+  if (!Array.isArray(config.schemas)) {
+    throw new Error("Config must have a 'schemas' array");
+  }
+  if (!config.schemas.every((s) => typeof s === "string")) {
+    throw new Error("All schemas must be strings");
+  }
+  if (config.output !== void 0 && typeof config.output !== "string") {
+    throw new Error("Config 'output' must be a string if provided");
+  }
+  return {
+    schemas: config.schemas,
+    output: config.output
+  };
+}
+
+// src/cli/output-generator.ts
+function generateOutput(options) {
+  const { schemas, includeHelper = true } = options;
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const schemaList = schemas.map((s) => s.uri).join(", ");
+  const lines = [];
+  lines.push("// Auto-generated by @tokens-studio/tokenscript-schemas");
+  lines.push(`// Generated: ${timestamp}`);
+  lines.push(`// Schemas: ${schemaList}`);
+  lines.push("");
+  lines.push('import { Config } from "@tokens-studio/tokenscript-interpreter";');
+  lines.push("");
+  lines.push("export const SCHEMAS = [");
+  for (const entry of schemas) {
+    const schemaJson = JSON.stringify(entry.schema, null, 2);
+    const uriJson = JSON.stringify(entry.uri);
+    const indentedSchema = schemaJson.split("\n").map((line) => `    ${line}`).join("\n");
+    lines.push(`  {`);
+    lines.push(`    uri: ${uriJson},`);
+    lines.push(`    schema: ${indentedSchema.trim()}`);
+    lines.push(`  },`);
+  }
+  lines.push("];");
+  lines.push("");
+  if (includeHelper) {
+    lines.push("export function makeConfig() {");
+    lines.push("  return new Config().registerSchemas(SCHEMAS);");
+    lines.push("}");
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/cli/commands/bundle.ts
+var log2 = ulog__default.default("bundle");
+async function loadConfig(configPath) {
+  try {
+    const content = await promises.readFile(configPath, "utf-8");
+    const parsed = JSON.parse(content);
+    return validateBundleConfig(parsed);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new Error(`Config file not found: ${configPath}`);
+    }
+    throw error;
+  }
+}
+function formatDependencyTree(tree, requestedSchemas) {
+  const lines = [];
+  const visited = /* @__PURE__ */ new Set();
+  lines.push("Dependency tree:");
+  lines.push("");
+  const formatNode = (key, indent = "", isLast = true) => {
+    if (visited.has(key)) {
+      return;
+    }
+    visited.add(key);
+    const node = tree.get(key);
+    if (!node) return;
+    const prefix = indent + (isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ");
+    const label = `${node.type}:${node.slug}`;
+    lines.push(prefix + label);
+    if (node.dependencies.length > 0) {
+      const childIndent = indent + (isLast ? "    " : "\u2502   ");
+      node.dependencies.forEach((dep, idx) => {
+        const isLastChild = idx === node.dependencies.length - 1;
+        const childKey = dep;
+        if (visited.has(childKey)) {
+          const childPrefix = childIndent + (isLastChild ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ");
+          lines.push(`${childPrefix + childKey} (already visited)`);
+        } else {
+          formatNode(childKey, childIndent, isLastChild);
+        }
+      });
+    }
+  };
+  requestedSchemas.forEach((schema, idx) => {
+    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");
+}
+function formatDryRunOutput(schemas, resolvedDependencies) {
+  const lines = [];
+  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");
+}
+async function bundleSchemas(schemas) {
+  const schemasDir = path.join(process.cwd(), "src/schemas");
+  log2.info("Bundling schemas:", schemas);
+  const result = await bundleSelectiveSchemas({
+    schemas,
+    schemasDir
+  });
+  log2.info(
+    `Resolved ${result.metadata.resolvedDependencies.length} schemas (including dependencies)`
+  );
+  const output = generateOutput({
+    schemas: result.schemas,
+    includeHelper: true
+  });
+  return {
+    output,
+    metadata: result.metadata,
+    dependencyTree: result.dependencyTree
+  };
+}
+async function handleBundleCommand(schemas, options = {}) {
+  try {
+    let configSchemas = schemas;
+    let outputPath = options.output || "./tokenscript-schemas.js";
+    if (isSome(options.config)) {
+      log2.info(`Loading config from ${options.config}`);
+      const config = await loadConfig(options.config);
+      configSchemas = config.schemas;
+      if (config.output) {
+        outputPath = config.output;
+      }
+    }
+    if (!configSchemas || configSchemas.length === 0) {
+      throw new Error("No schemas specified. Provide schemas as arguments or via --config");
+    }
+    const { output, metadata, dependencyTree } = await bundleSchemas(configSchemas);
+    console.log("");
+    console.log(formatDependencyTree(dependencyTree, metadata.requestedSchemas));
+    console.log("");
+    if (options.dryRun) {
+      const preview = formatDryRunOutput(metadata.requestedSchemas, metadata.resolvedDependencies);
+      console.log(preview);
+      return;
+    }
+    await promises.mkdir(path.dirname(outputPath), { recursive: true });
+    await promises.writeFile(outputPath, output, "utf-8");
+    log2.info(`Successfully bundled ${metadata.resolvedDependencies.length} schemas`);
+    log2.info(`Output written to: ${outputPath}`);
+    console.log(`\u2713 Bundled ${metadata.resolvedDependencies.length} schemas \u2192 ${outputPath}`);
+  } catch (error) {
+    log2.error("Bundle failed:", error);
+    throw error;
+  }
+}
+var log3 = ulog__default.default("list");
+async function listSchemas(schemasDir = path.join(process.cwd(), "src/schemas"), options = {}) {
+  const showTypes = options.types || !options.types && !options.functions;
+  const showFunctions = options.functions || !options.types && !options.functions;
+  const types = [];
+  const functions = [];
+  if (showTypes) {
+    try {
+      const typesDir = path.join(schemasDir, "types");
+      const typeEntries = await promises.readdir(typesDir, { withFileTypes: true });
+      types.push(
+        ...typeEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
+      );
+    } catch (error) {
+      log3.warn("Could not read types directory:", error);
+    }
+  }
+  if (showFunctions) {
+    try {
+      const functionsDir = path.join(schemasDir, "functions");
+      const funcEntries = await promises.readdir(functionsDir, { withFileTypes: true });
+      functions.push(
+        ...funcEntries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort()
+      );
+    } catch (error) {
+      log3.warn("Could not read functions directory:", error);
+    }
+  }
+  return { types, functions };
+}
+function formatListOutput(result, options = {}) {
+  const lines = [];
+  const showTypes = options.types || !options.types && !options.functions;
+  const showFunctions = options.functions || !options.types && !options.functions;
+  if (showTypes && result.types.length > 0) {
+    lines.push("Types:");
+    for (const type of result.types) {
+      lines.push(`  ${type}`);
+    }
+  }
+  if (showFunctions && result.functions.length > 0) {
+    if (lines.length > 0) lines.push("");
+    lines.push("Functions:");
+    for (const func of result.functions) {
+      lines.push(`  function:${func}`);
+    }
+  }
+  if (lines.length === 0) {
+    lines.push("No schemas found.");
+  }
+  return lines.join("\n");
+}
+async function handleListCommand(options = {}) {
+  const result = await listSchemas(void 0, options);
+  const output = formatListOutput(result, options);
+  console.log(output);
+}
+
+// src/cli/index.ts
+var log4 = ulog__default.default("cli");
+var cli = cac__default.default("tokenscript-schemas");
+cli.command("bundle [...schemas]", "Bundle schemas into a JS file").option("-c, --config <path>", "Path to config file").option("-o, --output <path>", "Output file path", { default: "./tokenscript-schemas.js" }).option("-d, --dry-run", "Preview what would be bundled without writing").action(async (schemas, options) => {
+  try {
+    await handleBundleCommand(schemas, options);
+  } catch (error) {
+    log4.error("Error:", error);
+    process.exit(1);
+  }
+});
+cli.command("list", "List available schemas").option("--types", "List only type schemas").option("--functions", "List only function schemas").action(async (options) => {
+  try {
+    await handleListCommand(options);
+  } catch (error) {
+    log4.error("Error:", error);
+    process.exit(1);
+  }
+});
+cli.help();
+cli.version("0.0.10");
+cli.parse();
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map