@tokens-studio/tokenscript-schemas 0.0.10

package/dist/index.d.cts

@@ -0,0 +1,158 @@
+/**
+ * Types for schema bundler
+ */
+interface SchemaFile {
+    path: string;
+    content: string;
+}
+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;
+    };
+}
+interface ScriptBlock {
+    type: string;
+    script: string;
+}
+interface Initializer {
+    title?: string;
+    keyword: string;
+    description?: string;
+    schema?: unknown;
+    script: ScriptBlock;
+}
+interface Conversion {
+    source: string;
+    target: string;
+    description?: string;
+    lossless: boolean;
+    script: ScriptBlock;
+}
+interface SpecProperty {
+    type: "number" | "string" | "color";
+}
+interface SpecSchema {
+    type: "object";
+    properties: Record<string, SpecProperty>;
+    required?: string[];
+    order?: string[];
+    additionalProperties?: boolean;
+}
+interface ColorSpecification {
+    name: string;
+    type: "color";
+    description?: string;
+    schema?: SpecSchema;
+    initializers: Initializer[];
+    conversions: Conversion[];
+    slug?: string;
+}
+interface FunctionSpecification {
+    name: string;
+    type: "function";
+    input?: {
+        type: "object";
+        properties?: Record<string, unknown>;
+    };
+    script: ScriptBlock;
+    keyword: string;
+    description?: string;
+    requirements?: string[];
+    slug?: string;
+}
+type SchemaSpecification = ColorSpecification | FunctionSpecification;
+interface BundledRegistry {
+    version: string;
+    types: ColorSpecification[];
+    functions: FunctionSpecification[];
+    metadata: {
+        generatedAt: string;
+        totalSchemas: number;
+    };
+}
+
+/**
+ * Schema bundler - bundles schemas for distribution
+ */
+
+/**
+ * Bundle all schemas from the schemas directory
+ */
+declare function bundleAllSchemas(schemasDir: string, outputDir: string): Promise<BundledRegistry>;
+
+/**
+ * Types for schema downloader
+ */
+interface LatestVersion {
+    id: string;
+    version: string;
+    created_at: string;
+}
+interface SchemaListItem {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    license_name: string | null;
+    type: "type" | "function";
+    latest: LatestVersion;
+}
+interface SchemaVersion {
+    id: string;
+    type: "type" | "function";
+    schema: string;
+    slug: string;
+    version: string;
+    content: unknown;
+    status?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+interface SchemaDetails {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    type: "type" | "function";
+    version: string;
+    content: unknown;
+    metadata?: Record<string, unknown>;
+}
+interface SchemaConfig {
+    apiBaseUrl: string;
+    outputDir: string;
+    targetVersion: string;
+}
+
+/**
+ * Schema downloader - fetches schemas from the TokenScript API
+ */
+
+declare const DEFAULT_CONFIG: SchemaConfig;
+/**
+ * Fetch all schemas from the API
+ */
+declare function fetchSchemaList(config?: SchemaConfig): Promise<SchemaListItem[]>;
+/**
+ * Fetch versions for a schema
+ */
+declare function fetchSchemaVersions(schemaSlug: string, config?: SchemaConfig): Promise<SchemaVersion[]>;
+/**
+ * Download and organize a single schema
+ */
+declare function downloadSchema(schema: SchemaListItem, config?: SchemaConfig): Promise<void>;
+/**
+ * Download all schemas from the API
+ */
+declare function downloadAllSchemas(config?: Partial<SchemaConfig>): Promise<void>;
+
+export { type BundledRegistry, type ColorSpecification, type Conversion, DEFAULT_CONFIG, type FunctionSpecification, type Initializer, type LatestVersion, type SchemaBundle, type SchemaConfig, type SchemaDetails, type SchemaFile, type SchemaListItem, type SchemaSpecification, type SchemaVersion, type ScriptBlock, type SpecProperty, type SpecSchema, bundleAllSchemas, downloadAllSchemas, downloadSchema, fetchSchemaList, fetchSchemaVersions };

package/dist/index.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Types for schema bundler
+ */
+interface SchemaFile {
+    path: string;
+    content: string;
+}
+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;
+    };
+}
+interface ScriptBlock {
+    type: string;
+    script: string;
+}
+interface Initializer {
+    title?: string;
+    keyword: string;
+    description?: string;
+    schema?: unknown;
+    script: ScriptBlock;
+}
+interface Conversion {
+    source: string;
+    target: string;
+    description?: string;
+    lossless: boolean;
+    script: ScriptBlock;
+}
+interface SpecProperty {
+    type: "number" | "string" | "color";
+}
+interface SpecSchema {
+    type: "object";
+    properties: Record<string, SpecProperty>;
+    required?: string[];
+    order?: string[];
+    additionalProperties?: boolean;
+}
+interface ColorSpecification {
+    name: string;
+    type: "color";
+    description?: string;
+    schema?: SpecSchema;
+    initializers: Initializer[];
+    conversions: Conversion[];
+    slug?: string;
+}
+interface FunctionSpecification {
+    name: string;
+    type: "function";
+    input?: {
+        type: "object";
+        properties?: Record<string, unknown>;
+    };
+    script: ScriptBlock;
+    keyword: string;
+    description?: string;
+    requirements?: string[];
+    slug?: string;
+}
+type SchemaSpecification = ColorSpecification | FunctionSpecification;
+interface BundledRegistry {
+    version: string;
+    types: ColorSpecification[];
+    functions: FunctionSpecification[];
+    metadata: {
+        generatedAt: string;
+        totalSchemas: number;
+    };
+}
+
+/**
+ * Schema bundler - bundles schemas for distribution
+ */
+
+/**
+ * Bundle all schemas from the schemas directory
+ */
+declare function bundleAllSchemas(schemasDir: string, outputDir: string): Promise<BundledRegistry>;
+
+/**
+ * Types for schema downloader
+ */
+interface LatestVersion {
+    id: string;
+    version: string;
+    created_at: string;
+}
+interface SchemaListItem {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    license_name: string | null;
+    type: "type" | "function";
+    latest: LatestVersion;
+}
+interface SchemaVersion {
+    id: string;
+    type: "type" | "function";
+    schema: string;
+    slug: string;
+    version: string;
+    content: unknown;
+    status?: string;
+    created_at?: string;
+    updated_at?: string;
+}
+interface SchemaDetails {
+    id: string;
+    slug: string;
+    name: string;
+    description: string;
+    type: "type" | "function";
+    version: string;
+    content: unknown;
+    metadata?: Record<string, unknown>;
+}
+interface SchemaConfig {
+    apiBaseUrl: string;
+    outputDir: string;
+    targetVersion: string;
+}
+
+/**
+ * Schema downloader - fetches schemas from the TokenScript API
+ */
+
+declare const DEFAULT_CONFIG: SchemaConfig;
+/**
+ * Fetch all schemas from the API
+ */
+declare function fetchSchemaList(config?: SchemaConfig): Promise<SchemaListItem[]>;
+/**
+ * Fetch versions for a schema
+ */
+declare function fetchSchemaVersions(schemaSlug: string, config?: SchemaConfig): Promise<SchemaVersion[]>;
+/**
+ * Download and organize a single schema
+ */
+declare function downloadSchema(schema: SchemaListItem, config?: SchemaConfig): Promise<void>;
+/**
+ * Download all schemas from the API
+ */
+declare function downloadAllSchemas(config?: Partial<SchemaConfig>): Promise<void>;
+
+export { type BundledRegistry, type ColorSpecification, type Conversion, DEFAULT_CONFIG, type FunctionSpecification, type Initializer, type LatestVersion, type SchemaBundle, type SchemaConfig, type SchemaDetails, type SchemaFile, type SchemaListItem, type SchemaSpecification, type SchemaVersion, type ScriptBlock, type SpecProperty, type SpecSchema, bundleAllSchemas, downloadAllSchemas, downloadSchema, fetchSchemaList, fetchSchemaVersions };

package/dist/index.js

@@ -0,0 +1,326 @@
+import { mkdir, writeFile, readdir, stat, readFile } from 'fs/promises';
+import { join } from 'path';
+
+// src/bundler/index.ts
+async function bundleSchemaFromDirectory(schemaDir, options) {
+  const schemaJsonPath = join(schemaDir, "schema.json");
+  const schemaContent = await 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 = join(schemaDir, initializer.script.script.slice(2));
+      const scriptContent = await 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 = join(schemaDir, conversion.script.script.slice(2));
+      const scriptContent = await 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 = join(schemaDir, result.script.script.slice(2));
+    const scriptContent = await 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;
+}
+async function isDirectory(path) {
+  try {
+    const stats = await stat(path);
+    return stats.isDirectory();
+  } catch {
+    return false;
+  }
+}
+async function getSubdirectories(dir) {
+  const entries = await readdir(dir);
+  const subdirs = [];
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    if (await isDirectory(fullPath)) {
+      subdirs.push(entry);
+    }
+  }
+  return subdirs;
+}
+
+// src/bundler/index.ts
+var DEFAULT_REGISTRY_URL = "https://schema.tokenscript.dev.gcp.tokens.studio";
+async function bundleSchema(schemaDir, schemaSlug) {
+  const bundled = await bundleSchemaFromDirectory(schemaDir, {
+    baseUrl: DEFAULT_REGISTRY_URL
+  });
+  bundled.slug = schemaSlug;
+  return bundled;
+}
+async function bundleTypeCategory(categoryDir) {
+  const bundles = [];
+  const schemaSlugs = await getSubdirectories(categoryDir);
+  for (const slug of schemaSlugs) {
+    const schemaDir = join(categoryDir, slug);
+    console.log(`  Bundling ${slug}...`);
+    try {
+      const bundle = await bundleSchema(schemaDir, slug);
+      if (bundle.type === "color") {
+        bundles.push(bundle);
+      }
+    } catch (error) {
+      console.error(`  \u2717 Failed to bundle ${slug}:`, error);
+    }
+  }
+  return bundles;
+}
+async function bundleFunctionCategory(categoryDir) {
+  const bundles = [];
+  const schemaSlugs = await getSubdirectories(categoryDir);
+  for (const slug of schemaSlugs) {
+    const schemaDir = join(categoryDir, slug);
+    console.log(`  Bundling ${slug}...`);
+    try {
+      const bundle = await bundleSchema(schemaDir, slug);
+      if (bundle.type === "function") {
+        bundles.push(bundle);
+      }
+    } catch (error) {
+      console.error(`  \u2717 Failed to bundle ${slug}:`, error);
+    }
+  }
+  return bundles;
+}
+async function bundleAllSchemas(schemasDir, outputDir) {
+  console.log("\nBundling type schemas...");
+  const typesDir = join(schemasDir, "types");
+  const types = await bundleTypeCategory(typesDir);
+  console.log(`\u2713 Bundled ${types.length} type schemas`);
+  console.log("\nBundling function schemas...");
+  const functionsDir = join(schemasDir, "functions");
+  const functions = await bundleFunctionCategory(functionsDir);
+  console.log(`\u2713 Bundled ${functions.length} function schemas`);
+  const registry = {
+    version: "0.0.10",
+    types,
+    functions,
+    metadata: {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalSchemas: types.length + functions.length
+    }
+  };
+  await mkdir(outputDir, { recursive: true });
+  const registryPath = join(outputDir, "registry.json");
+  await writeFile(registryPath, JSON.stringify(registry, null, 2));
+  console.log(`
+\u2713 Written complete registry to ${registryPath}`);
+  const typesPath = join(outputDir, "types.json");
+  await writeFile(typesPath, JSON.stringify({ version: registry.version, types }, null, 2));
+  console.log(`\u2713 Written types bundle to ${typesPath}`);
+  const functionsPath = join(outputDir, "functions.json");
+  await writeFile(functionsPath, JSON.stringify({ version: registry.version, functions }, null, 2));
+  console.log(`\u2713 Written functions bundle to ${functionsPath}`);
+  const typesOutputDir = join(outputDir, "types");
+  await mkdir(typesOutputDir, { recursive: true });
+  for (const type of types) {
+    const typePath = join(typesOutputDir, `${type.slug}.json`);
+    await writeFile(typePath, JSON.stringify(type, null, 2));
+  }
+  console.log(`\u2713 Written ${types.length} individual type schemas`);
+  const functionsOutputDir = join(outputDir, "functions");
+  await mkdir(functionsOutputDir, { recursive: true });
+  for (const func of functions) {
+    const funcPath = join(functionsOutputDir, `${func.slug}.json`);
+    await writeFile(funcPath, JSON.stringify(func, null, 2));
+  }
+  console.log(`\u2713 Written ${functions.length} individual function schemas`);
+  return registry;
+}
+var DEFAULT_CONFIG = {
+  apiBaseUrl: "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1",
+  outputDir: "src/schemas",
+  targetVersion: "0.0.10"
+};
+async function fetchSchemaList(config = DEFAULT_CONFIG) {
+  const url = `${config.apiBaseUrl}/schema/?format=json`;
+  console.log(`Fetching schema list from ${url}...`);
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch schemas: ${response.statusText}`);
+  }
+  const data = await response.json();
+  console.log(`Found ${data.length} schemas`);
+  return data;
+}
+async function fetchSchemaVersions(schemaSlug, config = DEFAULT_CONFIG) {
+  const url = `${config.apiBaseUrl}/schema/${schemaSlug}/versions/?format=json`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`Failed to fetch versions for ${schemaSlug}: ${response.statusText}`);
+  }
+  return await response.json();
+}
+async function createSchemaFolder(schemaSlug, schemaType, baseDir) {
+  const schemaPath = join(baseDir, schemaType === "type" ? "types" : "functions", schemaSlug);
+  await mkdir(schemaPath, { recursive: true });
+  return schemaPath;
+}
+async function writeSchemaJson(schemaPath, schema, targetVersion) {
+  const content = schema.content;
+  const schemaJson = {
+    id: schema.id,
+    slug: schema.slug,
+    name: schema.name,
+    description: schema.description,
+    type: schema.type,
+    version: targetVersion,
+    originalVersion: schema.version,
+    contentType: content.type || null,
+    metadata: schema.metadata || {}
+  };
+  await writeFile(join(schemaPath, "schema.json"), JSON.stringify(schemaJson, null, 2));
+}
+async function createUnitTestStub(schemaPath, schemaName, schemaType) {
+  const testContent = `import { describe, test, expect } from "vitest";
+
+describe("${schemaName}", () => {
+  test.todo("should implement ${schemaType} functionality");
+});
+`;
+  await writeFile(join(schemaPath, "unit.test.ts"), testContent);
+}
+function getConversionFileName(source, target) {
+  const extractType = (url) => {
+    const match = url.match(/\/([^/]+)\/\d+\/?$/);
+    return match ? match[1] : url;
+  };
+  const sourceType = extractType(source);
+  const targetType = extractType(target);
+  if (target === "$self") {
+    return `to-${sourceType}.tokenscript`;
+  }
+  if (source === "$self") {
+    return `from-${targetType}.tokenscript`;
+  }
+  return `${sourceType}-to-${targetType}.tokenscript`;
+}
+async function writeTokenScriptFiles(schemaPath, schema) {
+  const content = schema.content;
+  if (content.schema) {
+    await writeFile(
+      join(schemaPath, "schema-definition.json"),
+      JSON.stringify(content.schema, null, 2)
+    );
+  }
+  if (content.conversions && Array.isArray(content.conversions)) {
+    for (const conversion of content.conversions) {
+      if (conversion.script?.script) {
+        const fileName = getConversionFileName(conversion.source || "", conversion.target || "");
+        let scriptContent = "";
+        if (conversion.description) {
+          scriptContent += `# ${conversion.description}
+`;
+          scriptContent += `# Source: ${conversion.source}
+`;
+          scriptContent += `# Target: ${conversion.target}
+`;
+          scriptContent += `# Lossless: ${conversion.lossless || false}
+
+`;
+        }
+        scriptContent += conversion.script.script;
+        await writeFile(join(schemaPath, fileName), scriptContent);
+      }
+    }
+  }
+  if (!content.conversions || content.conversions.length === 0) {
+    const initializerContent = `# ${schema.name} Initializer
+# TODO: Implement initialization logic
+
+`;
+    await writeFile(join(schemaPath, "initializer.tokenscript"), initializerContent);
+  }
+}
+async function downloadSchema(schema, config = DEFAULT_CONFIG) {
+  console.log(`Downloading ${schema.slug}...`);
+  const versions = await fetchSchemaVersions(schema.slug, config);
+  if (versions.length === 0) {
+    console.warn(`No versions found for ${schema.slug}, skipping`);
+    return;
+  }
+  const latestVersion = versions[0];
+  const schemaPath = await createSchemaFolder(schema.slug, schema.type, config.outputDir);
+  const details = {
+    id: schema.id,
+    slug: schema.slug,
+    name: schema.name,
+    description: schema.description,
+    type: schema.type,
+    version: latestVersion.version,
+    content: latestVersion.content
+  };
+  await writeSchemaJson(schemaPath, details, config.targetVersion);
+  await writeTokenScriptFiles(schemaPath, details);
+  await createUnitTestStub(schemaPath, schema.name, schema.type);
+  console.log(`\u2713 Downloaded ${schema.slug} to ${schemaPath}`);
+}
+async function downloadAllSchemas(config = {}) {
+  const fullConfig = { ...DEFAULT_CONFIG, ...config };
+  const schemas = await fetchSchemaList(fullConfig);
+  for (const schema of schemas) {
+    try {
+      await downloadSchema(schema, fullConfig);
+    } catch (error) {
+      console.error(`Failed to download ${schema.slug}:`, error);
+    }
+  }
+  console.log("\n\u2713 All schemas downloaded successfully!");
+}
+
+export { DEFAULT_CONFIG, bundleAllSchemas, downloadAllSchemas, downloadSchema, fetchSchemaList, fetchSchemaVersions };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map