@tokens-studio/tokenscript-schemas 0.0.11 → 0.0.13

package/src/schemas/types/srgb-color/from-linear.tokenscript

@@ -0,0 +1,58 @@
+// Linear sRGB to sRGB Conversion
+// Applies gamma correction (transfer function)
+// Reference: IEC 61966-2-1:1999 (sRGB specification)
+//
+// Algorithm:
+//   if linear ≤ 0.0031308: srgb = linear * 12.92
+//   else: srgb = 1.055 * linear^(1/2.4) - 0.055
+//
+// Input: Color.LinearSRGB with r, g, b in linear 0-1 range
+// Output: Color.SRGB with r, g, b in gamma-corrected 0-1 range
+
+// Gamma correction constants (IEC 61966-2-1)
+variable threshold: Number = 0.0031308;
+variable linear_scale: Number = 12.92;
+variable gamma_offset: Number = 0.055;
+variable gamma_scale: Number = 1.055;
+variable gamma_exponent: Number = 0.416666666666667;
+
+// Get input linear values
+variable linear_r: Number = {input}.r;
+variable linear_g: Number = {input}.g;
+variable linear_b: Number = {input}.b;
+
+// Convert red channel
+variable srgb_r: Number = 0;
+if (linear_r <= threshold) [
+    srgb_r = linear_r * linear_scale;
+] else [
+    srgb_r = gamma_scale * pow(linear_r, gamma_exponent) - gamma_offset;
+];
+
+// Convert green channel
+variable srgb_g: Number = 0;
+if (linear_g <= threshold) [
+    srgb_g = linear_g * linear_scale;
+] else [
+    srgb_g = gamma_scale * pow(linear_g, gamma_exponent) - gamma_offset;
+];
+
+// Convert blue channel
+variable srgb_b: Number = 0;
+if (linear_b <= threshold) [
+    srgb_b = linear_b * linear_scale;
+] else [
+    srgb_b = gamma_scale * pow(linear_b, gamma_exponent) - gamma_offset;
+];
+
+// Create output
+variable output: Color.SRGB;
+output.r = srgb_r;
+output.g = srgb_g;
+output.b = srgb_b;
+
+return output;
+
+
+
+

package/src/schemas/types/srgb-color/from-rgb.tokenscript

@@ -0,0 +1,20 @@
+// RGB to sRGB Conversion
+// Converts RGB (0-255) to sRGB (0-1) by normalizing
+// Input: Color.Rgb with r, g, b in 0-255 range
+// Output: Color.SRGB with r, g, b in 0-1 range
+// Lossless: Yes (simple division)
+
+variable r_normalized: Number = {input}.r / 255;
+variable g_normalized: Number = {input}.g / 255;
+variable b_normalized: Number = {input}.b / 255;
+
+variable output: Color.SRGB;
+output.r = r_normalized;
+output.g = g_normalized;
+output.b = b_normalized;
+
+return output;
+
+
+
+

package/src/schemas/types/srgb-color/initializer.tokenscript

@@ -0,0 +1,16 @@
+// sRGB Color Initializer
+// Creates an sRGB color from normalized 0-1 values
+// Input: List of [r, g, b] values in 0-1 range
+
+variable color_values: List = {input};
+variable output: Color.SRGB;
+
+output.r = color_values.get(0);
+output.g = color_values.get(1);
+output.b = color_values.get(2);
+
+return output;
+
+
+
+

package/src/schemas/types/srgb-color/schema.json

@@ -0,0 +1,68 @@
+{
+  "name": "SRGB",
+  "type": "color",
+  "description": "sRGB color space with normalized 0-1 range. The standard color space for web and displays.",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "r": {
+        "type": "number",
+        "description": "Red channel (0-1)"
+      },
+      "g": {
+        "type": "number",
+        "description": "Green channel (0-1)"
+      },
+      "b": {
+        "type": "number",
+        "description": "Blue channel (0-1)"
+      }
+    },
+    "required": ["r", "g", "b"],
+    "order": ["r", "g", "b"],
+    "additionalProperties": false
+  },
+  "initializers": [
+    {
+      "title": "sRGB Color Initializer",
+      "keyword": "srgb",
+      "description": "Creates an sRGB color from normalized 0-1 values",
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./initializer.tokenscript"
+      }
+    }
+  ],
+  "conversions": [
+    {
+      "source": "/api/v1/core/rgb-color/0/",
+      "target": "$self",
+      "description": "Converts RGB (0-255) to sRGB (0-1) by normalizing",
+      "lossless": true,
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./from-rgb.tokenscript"
+      }
+    },
+    {
+      "source": "/api/v1/core/hsl-color/0/",
+      "target": "$self",
+      "description": "Converts HSL to sRGB",
+      "lossless": true,
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./from-hsl.tokenscript"
+      }
+    },
+    {
+      "source": "/api/v1/core/srgb-linear-color/0/",
+      "target": "$self",
+      "description": "Converts Linear sRGB to sRGB by applying gamma correction",
+      "lossless": true,
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./from-linear.tokenscript"
+      }
+    }
+  ]
+}

package/src/schemas/types/srgb-color/unit.test.ts

@@ -0,0 +1,303 @@
+/**
+ * sRGB Color Schema Tests
+ *
+ * Tests for the sRGB color space (normalized 0-1 range)
+ * Validates against ColorJS for parity
+ */
+
+import { log } from "@tests/helpers/logger";
+import { executeWithSchema, getBundledSchema } from "@tests/helpers/schema-test-utils";
+import Color from "colorjs.io";
+import { describe, expect, it } from "vitest";
+import type { ColorSpecification } from "@/bundler/types";
+
+// ColorJS reference tolerance
+const TOLERANCE = 1e-10;
+
+describe("sRGB Color Schema", () => {
+  describe("Schema Definition", () => {
+    it("should have correct schema structure", async () => {
+      const schema = (await getBundledSchema("srgb-color")) as ColorSpecification;
+
+      expect(schema.name).toBe("SRGB");
+      expect(schema.type).toBe("color");
+      expect(schema.schema).toBeDefined();
+      expect(schema.schema?.properties).toHaveProperty("r");
+      expect(schema.schema?.properties).toHaveProperty("g");
+      expect(schema.schema?.properties).toHaveProperty("b");
+      expect(schema.schema?.required).toEqual(["r", "g", "b"]);
+    });
+
+    it("should have srgb initializer", async () => {
+      const schema = (await getBundledSchema("srgb-color")) as ColorSpecification;
+
+      expect(schema.initializers).toHaveLength(1);
+      expect(schema.initializers[0].keyword).toBe("srgb");
+      expect(schema.initializers[0].script.script).toContain("Color.SRGB");
+    });
+
+    it("should have conversion from RGB", async () => {
+      const schema = (await getBundledSchema("srgb-color")) as ColorSpecification;
+
+      expect(schema.conversions.length).toBeGreaterThanOrEqual(1);
+
+      const rgbToSrgb = schema.conversions.find((c: { source: string }) =>
+        c.source.includes("rgb-color"),
+      );
+      expect(rgbToSrgb).toBeDefined();
+      expect(rgbToSrgb?.lossless).toBe(true);
+    });
+  });
+
+  describe("Initialization", () => {
+    it("should create sRGB color from normalized values", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable c: Color.SRGB;
+        c.r = 1.0;
+        c.g = 0.5;
+        c.b = 0.25;
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("SRGB");
+      expect((result as any).value.r.value).toBeCloseTo(1.0, 10);
+      expect((result as any).value.g.value).toBeCloseTo(0.5, 10);
+      expect((result as any).value.b.value).toBeCloseTo(0.25, 10);
+    });
+
+    it("should handle black (0, 0, 0)", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable c: Color.SRGB;
+        c.r = 0;
+        c.g = 0;
+        c.b = 0;
+        c
+      `,
+      );
+
+      expect((result as any).value.r.value).toBe(0);
+      expect((result as any).value.g.value).toBe(0);
+      expect((result as any).value.b.value).toBe(0);
+    });
+
+    it("should handle white (1, 1, 1)", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable c: Color.SRGB;
+        c.r = 1;
+        c.g = 1;
+        c.b = 1;
+        c
+      `,
+      );
+
+      expect((result as any).value.r.value).toBe(1);
+      expect((result as any).value.g.value).toBe(1);
+      expect((result as any).value.b.value).toBe(1);
+    });
+  });
+
+  describe("Conversion from RGB (0-255) to sRGB (0-1)", () => {
+    it("should convert RGB red to sRGB", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 255;
+        rgb.g = 0;
+        rgb.b = 0;
+        rgb.to.srgb()
+      `,
+      );
+
+      // ColorJS reference
+      const colorJS = new Color("srgb", [1, 0, 0]);
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("SRGB");
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 10);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 10);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 10);
+    });
+
+    it("should convert RGB green to sRGB", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 0;
+        rgb.g = 255;
+        rgb.b = 0;
+        rgb.to.srgb()
+      `,
+      );
+
+      const colorJS = new Color("srgb", [0, 1, 0]);
+
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 10);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 10);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 10);
+    });
+
+    it("should convert RGB blue to sRGB", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 0;
+        rgb.g = 0;
+        rgb.b = 255;
+        rgb.to.srgb()
+      `,
+      );
+
+      const colorJS = new Color("srgb", [0, 0, 1]);
+
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 10);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 10);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 10);
+    });
+
+    it("should convert mid-gray RGB to sRGB", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 128;
+        rgb.g = 128;
+        rgb.b = 128;
+        rgb.to.srgb()
+      `,
+      );
+
+      // 128/255 ≈ 0.50196
+      const expected = 128 / 255;
+
+      expect((result as any).value.r.value).toBeCloseTo(expected, 10);
+      expect((result as any).value.g.value).toBeCloseTo(expected, 10);
+      expect((result as any).value.b.value).toBeCloseTo(expected, 10);
+    });
+
+    it("should convert coral (#ff5733) RGB to sRGB", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 255;
+        rgb.g = 87;
+        rgb.b = 51;
+        rgb.to.srgb()
+      `,
+      );
+
+      // ColorJS reference
+      const colorJS = new Color("#ff5733");
+
+      expect((result as any).value.r.value).toBeCloseTo(colorJS.coords[0], 5);
+      expect((result as any).value.g.value).toBeCloseTo(colorJS.coords[1], 5);
+      expect((result as any).value.b.value).toBeCloseTo(colorJS.coords[2], 5);
+    });
+  });
+
+  describe("ColorJS Parity", () => {
+    const testCases = [
+      { name: "red", rgb: [255, 0, 0], srgb: [1, 0, 0] },
+      { name: "green", rgb: [0, 255, 0], srgb: [0, 1, 0] },
+      { name: "blue", rgb: [0, 0, 255], srgb: [0, 0, 1] },
+      { name: "black", rgb: [0, 0, 0], srgb: [0, 0, 0] },
+      { name: "white", rgb: [255, 255, 255], srgb: [1, 1, 1] },
+      { name: "gray", rgb: [128, 128, 128], srgb: [128 / 255, 128 / 255, 128 / 255] },
+      { name: "coral", rgb: [255, 87, 51], srgb: [1, 87 / 255, 51 / 255] },
+    ];
+
+    for (const { name, rgb, srgb } of testCases) {
+      it(`should match ColorJS for ${name}`, async () => {
+        const result = await executeWithSchema(
+          "srgb-color",
+          "type",
+          `
+          variable rgb: Color.Rgb;
+          rgb.r = ${rgb[0]};
+          rgb.g = ${rgb[1]};
+          rgb.b = ${rgb[2]};
+          rgb.to.srgb()
+        `,
+        );
+
+        // ColorJS reference
+        const colorJS = new Color("srgb", srgb as [number, number, number]);
+
+        const tsR = (result as any).value.r.value;
+        const tsG = (result as any).value.g.value;
+        const tsB = (result as any).value.b.value;
+
+        const diffR = Math.abs(tsR - colorJS.coords[0]);
+        const diffG = Math.abs(tsG - colorJS.coords[1]);
+        const diffB = Math.abs(tsB - colorJS.coords[2]);
+        const maxDiff = Math.max(diffR, diffG, diffB);
+
+        // Log for documentation (only shown when LOG_LEVEL is set)
+        log.info(`\n=== ${name.toUpperCase()} ColorJS Parity ===`);
+        log.info(`TokenScript: { r: ${tsR}, g: ${tsG}, b: ${tsB} }`);
+        log.info(
+          `ColorJS:     { r: ${colorJS.coords[0]}, g: ${colorJS.coords[1]}, b: ${colorJS.coords[2]} }`,
+        );
+        log.info(`Max Diff:    ${maxDiff.toExponential(2)}`);
+        log.info(`Status:      ${maxDiff < TOLERANCE ? "✅ PASS" : "❌ FAIL"}`);
+
+        expect(maxDiff).toBeLessThan(TOLERANCE);
+      });
+    }
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle very small values", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 1;
+        rgb.g = 1;
+        rgb.b = 1;
+        rgb.to.srgb()
+      `,
+      );
+
+      const expected = 1 / 255;
+      expect((result as any).value.r.value).toBeCloseTo(expected, 10);
+    });
+
+    it("should handle near-max values", async () => {
+      const result = await executeWithSchema(
+        "srgb-color",
+        "type",
+        `
+        variable rgb: Color.Rgb;
+        rgb.r = 254;
+        rgb.g = 254;
+        rgb.b = 254;
+        rgb.to.srgb()
+      `,
+      );
+
+      const expected = 254 / 255;
+      expect((result as any).value.r.value).toBeCloseTo(expected, 10);
+    });
+  });
+});

package/src/schemas/types/srgb-linear-color/from-srgb.tokenscript

@@ -0,0 +1,55 @@
+// sRGB to Linear sRGB Conversion
+// Removes gamma correction (inverse transfer function)
+// Reference: IEC 61966-2-1:1999 (sRGB specification)
+//
+// Algorithm:
+//   if srgb ≤ 0.04045: linear = srgb / 12.92
+//   else: linear = ((srgb + 0.055) / 1.055) ^ 2.4
+//
+// Input: Color.SRGB with r, g, b in 0-1 range
+// Output: Color.LinearSRGB with r, g, b in linear 0-1 range
+
+// Gamma correction constants (IEC 61966-2-1)
+variable threshold: Number = 0.04045;
+variable linear_scale: Number = 12.92;
+variable gamma_offset: Number = 0.055;
+variable gamma_scale: Number = 1.055;
+variable gamma_exponent: Number = 2.4;
+
+// Get input sRGB values
+variable srgb_r: Number = {input}.r;
+variable srgb_g: Number = {input}.g;
+variable srgb_b: Number = {input}.b;
+
+// Convert red channel
+variable linear_r: Number = 0;
+if (srgb_r <= threshold) [
+    linear_r = srgb_r / linear_scale;
+] else [
+    linear_r = pow((srgb_r + gamma_offset) / gamma_scale, gamma_exponent);
+];
+
+// Convert green channel
+variable linear_g: Number = 0;
+if (srgb_g <= threshold) [
+    linear_g = srgb_g / linear_scale;
+] else [
+    linear_g = pow((srgb_g + gamma_offset) / gamma_scale, gamma_exponent);
+];
+
+// Convert blue channel
+variable linear_b: Number = 0;
+if (srgb_b <= threshold) [
+    linear_b = srgb_b / linear_scale;
+] else [
+    linear_b = pow((srgb_b + gamma_offset) / gamma_scale, gamma_exponent);
+];
+
+// Create output
+variable output: Color.LinearSRGB;
+output.r = linear_r;
+output.g = linear_g;
+output.b = linear_b;
+
+return output;
+

package/src/schemas/types/srgb-linear-color/from-xyz-d65.tokenscript

@@ -0,0 +1,34 @@
+// XYZ-D65 to Linear sRGB Conversion
+// Reference: ColorJS exact matrix values (extracted via unit vector conversion)
+//
+// Matrix (XYZ D65 to Linear sRGB):
+//   [ 3.2409699419045226, -1.537383177570094,  -0.4986107602930034 ]
+//   [-0.9692436362808796,  1.8759675015077202,  0.04155505740717559]
+//   [ 0.05563007969699366, -0.20397695888897652, 1.0569715142428786]
+//
+// Input: Color.XYZD65 with x, y, z tristimulus values
+// Output: Color.LinearSRGB with r, g, b in linear 0-1 range
+
+// Get input XYZ values
+variable x: Number = {input}.x;
+variable y: Number = {input}.y;
+variable z: Number = {input}.z;
+
+// Apply inverse matrix transformation (ColorJS exact values)
+// Row 1: R
+variable linear_r: Number = 3.2409699419045226 * x + -1.537383177570094 * y + -0.4986107602930034 * z;
+
+// Row 2: G
+variable linear_g: Number = -0.9692436362808796 * x + 1.8759675015077202 * y + 0.04155505740717559 * z;
+
+// Row 3: B
+variable linear_b: Number = 0.05563007969699366 * x + -0.20397695888897652 * y + 1.0569715142428786 * z;
+
+// Create output
+variable output: Color.LinearSRGB;
+output.r = linear_r;
+output.g = linear_g;
+output.b = linear_b;
+
+return output;
+

package/src/schemas/types/srgb-linear-color/initializer.tokenscript

@@ -0,0 +1,13 @@
+// Linear sRGB Color Initializer
+// Creates a linear sRGB color from linear 0-1 values
+// Input: List of [r, g, b] linear values
+
+variable color_values: List = {input};
+variable output: Color.LinearSRGB;
+
+output.r = color_values.get(0);
+output.g = color_values.get(1);
+output.b = color_values.get(2);
+
+return output;
+

package/src/schemas/types/srgb-linear-color/schema.json

@@ -0,0 +1,58 @@
+{
+  "name": "LinearSRGB",
+  "type": "color",
+  "description": "Linear sRGB color space (gamma-decoded). Used for matrix transformations to XYZ and other linear operations.",
+  "schema": {
+    "type": "object",
+    "properties": {
+      "r": {
+        "type": "number",
+        "description": "Linear red channel (0-1)"
+      },
+      "g": {
+        "type": "number",
+        "description": "Linear green channel (0-1)"
+      },
+      "b": {
+        "type": "number",
+        "description": "Linear blue channel (0-1)"
+      }
+    },
+    "required": ["r", "g", "b"],
+    "order": ["r", "g", "b"],
+    "additionalProperties": false
+  },
+  "initializers": [
+    {
+      "title": "Linear sRGB Color Initializer",
+      "keyword": "linearsrgb",
+      "description": "Creates a linear sRGB color from linear 0-1 values",
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./initializer.tokenscript"
+      }
+    }
+  ],
+  "conversions": [
+    {
+      "source": "/api/v1/core/srgb-color/0/",
+      "target": "$self",
+      "description": "Converts sRGB to Linear sRGB by removing gamma correction (IEC 61966-2-1)",
+      "lossless": true,
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./from-srgb.tokenscript"
+      }
+    },
+    {
+      "source": "/api/v1/core/xyz-d65-color/0/",
+      "target": "$self",
+      "description": "Converts XYZ-D65 to Linear sRGB using inverse transformation matrix",
+      "lossless": true,
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./from-xyz-d65.tokenscript"
+      }
+    }
+  ]
+}