@tokens-studio/tokenscript-schemas 0.0.13 → 0.1.0

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

@@ -1,6 +1,6 @@
 // CIE LCH Color Initializer
 // Creates a LCH color from L, C, H values
-// Input: List of [l, c, h] values
+// Input: List of [l, c, h] or [l, c, h, alpha] values
 
 variable lch_values: List = {input};
 variable output: Color.LCH;
@@ -9,6 +9,11 @@ output.l = lch_values.get(0);
 output.c = lch_values.get(1);
 output.h = lch_values.get(2);
 
+// Set alpha if provided as 4th parameter
+if (lch_values.length() > 3) [
+  output.alpha = lch_values.get(3);
+];
+
 return output;
 
 

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

@@ -170,4 +170,48 @@ describe("CIE LCH Color Schema", () => {
       expect((result as any).value.c.value).toBeLessThan(0.01);
     });
   });
+
+  describe("Alpha Channel Support", () => {
+    it("should accept optional 4th parameter for alpha", async () => {
+      const result = await executeWithSchema(
+        "lch-color",
+        "type",
+        `
+        variable c: Color.LCH = lch(50, 20, 180, 0.7);
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("LCH");
+      expect((result as any).alpha).toBe(0.7);
+    });
+
+    it("should get alpha property", async () => {
+      const result = await executeWithSchema(
+        "lch-color",
+        "type",
+        `
+        variable c: Color.LCH = lch(50, 20, 180, 0.5);
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.5);
+    });
+
+    it("should set alpha property", async () => {
+      const result = await executeWithSchema(
+        "lch-color",
+        "type",
+        `
+        variable c: Color.LCH = lch(50, 20, 180);
+        c.alpha = 0.8;
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.8);
+    });
+  });
 });

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

@@ -9,8 +9,9 @@
 // - h: Hue angle (0-360 degrees), same as OKLCH hue
 // - s: Saturation (0-1), normalized to sRGB gamut boundary
 // - l: Lightness (0-1), perceptually uniform with toe function
+// - alpha: Optional alpha channel (0-1)
 //
-// Input: Object with h, s, l properties
+// Input: Object with h, s, l, and optional alpha properties
 // Output: Color.OKHSL
 
 variable h: Number = input.h;
@@ -21,4 +22,10 @@ variable output: Color.OKHSL;
 output.h = h;
 output.s = s;
 output.l = l;
+
+// Set alpha if provided
+if (input.alpha != null) [
+  output.alpha = input.alpha;
+];
+
 output

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

@@ -511,4 +511,41 @@ describe("OKHSL Color Schema", () => {
       });
     });
   });
+
+  describe("Alpha Channel Support", () => {
+    it("should set and get alpha property", async () => {
+      const result = await executeWithSchema(
+        "okhsl-color",
+        "type",
+        `
+        variable c: Color.OKHSL;
+        c.h = 180;
+        c.s = 0.5;
+        c.l = 0.5;
+        c.alpha = 0.7;
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.7);
+    });
+
+    it("should preserve alpha through conversions", async () => {
+      const result = await executeWithSchema(
+        "okhsl-color",
+        "type",
+        `
+        variable c: Color.OKHSL;
+        c.h = 180;
+        c.s = 0.5;
+        c.l = 0.5;
+        c.alpha = 0.6;
+        variable oklab: Color.OKLab = c.to.oklab();
+        oklab.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.6);
+    });
+  });
 });

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

@@ -9,8 +9,9 @@
 // - h: Hue angle (0-360 degrees), same as OKLCH hue
 // - s: Saturation (0-1), ratio of chroma to maximum at this value
 // - v: Value/brightness (0-1), with V=1 being brightest for that saturation
+// - alpha: Optional alpha channel (0-1)
 //
-// Input: Object with h, s, v properties
+// Input: Object with h, s, v, and optional alpha properties
 // Output: Color.OKHSV
 
 variable h: Number = input.h;
@@ -21,4 +22,10 @@ variable output: Color.OKHSV;
 output.h = h;
 output.s = s;
 output.v = v;
+
+// Set alpha if provided
+if (input.alpha != null) [
+  output.alpha = input.alpha;
+];
+
 output

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

@@ -496,4 +496,41 @@ describe("OKHSV Color Schema", () => {
       });
     });
   });
+
+  describe("Alpha Channel Support", () => {
+    it("should set and get alpha property", async () => {
+      const result = await executeWithSchema(
+        "okhsv-color",
+        "type",
+        `
+        variable c: Color.OKHSV;
+        c.h = 180;
+        c.s = 0.5;
+        c.v = 0.5;
+        c.alpha = 0.7;
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.7);
+    });
+
+    it("should preserve alpha through conversions", async () => {
+      const result = await executeWithSchema(
+        "okhsv-color",
+        "type",
+        `
+        variable c: Color.OKHSV;
+        c.h = 180;
+        c.s = 0.5;
+        c.v = 0.5;
+        c.alpha = 0.6;
+        variable oklab: Color.OKLab = c.to.oklab();
+        oklab.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.6);
+    });
+  });
 });

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

@@ -1,6 +1,6 @@
 // OKLab Color Initializer
 // Creates an OKLab color from L, a, b values
-// Input: List of [l, a, b] values
+// Input: List of [l, a, b] or [l, a, b, alpha] values
 
 variable lab_values: List = {input};
 variable output: Color.OKLab;
@@ -9,6 +9,11 @@ output.l = lab_values.get(0);
 output.a = lab_values.get(1);
 output.b = lab_values.get(2);
 
+// Set alpha if provided as 4th parameter
+if (lab_values.length() > 3) [
+  output.alpha = lab_values.get(3);
+];
+
 return output;
 
 

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

@@ -342,4 +342,62 @@ describe("OKLab Color Schema", () => {
       expect(Math.abs((result as any).value.b.value)).toBeLessThan(1e-5);
     });
   });
+
+  describe("Alpha Channel Support", () => {
+    it("should accept optional 4th parameter for alpha", async () => {
+      const result = await executeWithSchema(
+        "oklab-color",
+        "type",
+        `
+        variable c: Color.OKLab = oklab(0.5, 0.1, 0.2, 0.7);
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("OKLab");
+      expect((result as any).alpha).toBe(0.7);
+    });
+
+    it("should get alpha property", async () => {
+      const result = await executeWithSchema(
+        "oklab-color",
+        "type",
+        `
+        variable c: Color.OKLab = oklab(0.5, 0.1, 0.2, 0.5);
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.5);
+    });
+
+    it("should set alpha property", async () => {
+      const result = await executeWithSchema(
+        "oklab-color",
+        "type",
+        `
+        variable c: Color.OKLab = oklab(0.5, 0.1, 0.2);
+        c.alpha = 0.8;
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.8);
+    });
+
+    it("should preserve alpha through conversions", async () => {
+      const result = await executeWithSchema(
+        "oklab-color",
+        "type",
+        `
+        variable c: Color.OKLab = oklab(0.5, 0.1, 0.2, 0.6);
+        variable oklch: Color.OKLCH = c.to.oklch();
+        oklch.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.6);
+    });
+  });
 });

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

@@ -1,6 +1,6 @@
 // OKLCH Color Initializer
 // Creates an OKLCH color from L, C, H values
-// Input: List of [l, c, h] values
+// Input: List of [l, c, h] or [l, c, h, alpha] values
 
 variable lch_values: List = {input};
 variable output: Color.OKLCH;
@@ -9,6 +9,11 @@ output.l = lch_values.get(0);
 output.c = lch_values.get(1);
 output.h = lch_values.get(2);
 
+// Set alpha if provided as 4th parameter
+if (lch_values.length() > 3) [
+  output.alpha = lch_values.get(3);
+];
+
 return output;
 
 

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

@@ -264,4 +264,62 @@ describe("OKLCH Color Schema", () => {
       expect((result as any).value.c.value).toBeLessThan(1e-5);
     });
   });
+
+  describe("Alpha Channel Support", () => {
+    it("should accept optional 4th parameter for alpha", async () => {
+      const result = await executeWithSchema(
+        "oklch-color",
+        "type",
+        `
+        variable c: Color.OKLCH = oklch(0.5, 0.1, 180, 0.7);
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("OKLCH");
+      expect((result as any).alpha).toBe(0.7);
+    });
+
+    it("should get alpha property", async () => {
+      const result = await executeWithSchema(
+        "oklch-color",
+        "type",
+        `
+        variable c: Color.OKLCH = oklch(0.5, 0.1, 180, 0.5);
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.5);
+    });
+
+    it("should set alpha property", async () => {
+      const result = await executeWithSchema(
+        "oklch-color",
+        "type",
+        `
+        variable c: Color.OKLCH = oklch(0.5, 0.1, 180);
+        c.alpha = 0.8;
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.8);
+    });
+
+    it("should preserve alpha through conversions", async () => {
+      const result = await executeWithSchema(
+        "oklch-color",
+        "type",
+        `
+        variable c: Color.OKLCH = oklch(0.5, 0.1, 180, 0.6);
+        variable oklab: Color.OKLab = c.to.oklab();
+        oklab.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.6);
+    });
+  });
 });

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

@@ -1,6 +1,6 @@
 // Display-P3 Color Initializer
 // Creates a Display-P3 color from 0-1 values
-// Input: List of [r, g, b] values
+// Input: List of [r, g, b] or [r, g, b, alpha] values
 
 variable color_values: List = {input};
 variable output: Color.P3;
@@ -9,6 +9,11 @@ output.r = color_values.get(0);
 output.g = color_values.get(1);
 output.b = color_values.get(2);
 
+// Set alpha if provided as 4th parameter
+if (color_values.length() > 3) [
+  output.alpha = color_values.get(3);
+];
+
 return output;
 
 

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

@@ -116,4 +116,51 @@ describe("Display-P3 Color Schema", () => {
       expect(colorJS_p3Green.coords[0]).toBeLessThan(0);
     });
   });
+
+  describe("Alpha Channel Support", () => {
+    it("should accept optional 4th parameter for alpha", async () => {
+      const result = await executeWithSchema(
+        "p3-color",
+        "type",
+        `
+        variable c: Color.P3 = p3(1, 0, 0, 0.7);
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("P3");
+      expect((result as any).value.r.value).toBe(1);
+      expect((result as any).value.g.value).toBe(0);
+      expect((result as any).value.b.value).toBe(0);
+      expect((result as any).alpha).toBe(0.7);
+    });
+
+    it("should get alpha property", async () => {
+      const result = await executeWithSchema(
+        "p3-color",
+        "type",
+        `
+        variable c: Color.P3 = p3(1, 0, 0, 0.5);
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.5);
+    });
+
+    it("should set alpha property", async () => {
+      const result = await executeWithSchema(
+        "p3-color",
+        "type",
+        `
+        variable c: Color.P3 = p3(1, 0, 0);
+        c.alpha = 0.8;
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.8);
+    });
+  });
 });

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

@@ -2,8 +2,9 @@
 // Creates an RGB color from r, g, b values (0-255 range)
 //
 // Usage: rgb(255, 128, 64) → Color.Rgb { r: 255, g: 128, b: 64 }
+//        rgb(255, 128, 64, 0.5) → Color.Rgb { r: 255, g: 128, b: 64, alpha: 0.5 }
 //
-// Input: List of 3 numbers [r, g, b]
+// Input: List of 3 or 4 numbers [r, g, b] or [r, g, b, alpha]
 // Output: Color.Rgb
 
 variable color_parts: List = {input}; 
@@ -13,4 +14,9 @@ output.r = color_parts.get(0);
 output.g = color_parts.get(1);
 output.b = color_parts.get(2);
 
+// Set alpha if provided as 4th parameter
+if (color_parts.length() > 3) [
+  output.alpha = color_parts.get(3);
+];
+
 return output;

package/src/schemas/types/rgb-color/rgba-initializer.tokenscript

@@ -0,0 +1,17 @@
+// RGBA Color Initializer
+// Creates an RGB color with alpha from r, g, b, a values
+//
+// Usage: rgba(255, 128, 64, 0.5) → Color.Rgb { r: 255, g: 128, b: 64, alpha: 0.5 }
+//
+// Input: List of 4 numbers [r, g, b, alpha]
+// Output: Color.Rgb with alpha
+
+variable color_parts: List = {input}; 
+
+variable output: Color.Rgb;
+output.r = color_parts.get(0);
+output.g = color_parts.get(1);
+output.b = color_parts.get(2);
+output.alpha = color_parts.get(3);
+
+return output;

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

@@ -28,6 +28,15 @@
         "type": "/api/v1/core/tokenscript/0/",
         "script": "./initializer.tokenscript"
       }
+    },
+    {
+      "title": "function",
+      "keyword": "rgba",
+      "description": "Creates an RGB color with alpha",
+      "script": {
+        "type": "/api/v1/core/tokenscript/0/",
+        "script": "./rgba-initializer.tokenscript"
+      }
     }
   ],
   "conversions": [

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

@@ -20,10 +20,13 @@ describe("RGB Color Schema", () => {
     it("should have initializers defined", async () => {
       const schema = (await getBundledSchema("rgb-color")) as ColorSpecification;
 
-      expect(schema.initializers).toHaveLength(1);
+      expect(schema.initializers).toHaveLength(2);
       expect(schema.initializers[0].keyword).toBe("rgb");
       expect(schema.initializers[0].script.script).toBeTruthy();
       expect(schema.initializers[0].script.script).not.toContain("./");
+      expect(schema.initializers[1].keyword).toBe("rgba");
+      expect(schema.initializers[1].script.script).toBeTruthy();
+      expect(schema.initializers[1].script.script).not.toContain("./");
     });
 
     it("should have conversions defined", async () => {
@@ -299,4 +302,110 @@ describe("RGB Color Schema", () => {
       expect((result as any).value.b.value).toBe(200);
     });
   });
+
+  describe("Alpha Channel Support", () => {
+    it("should accept optional 4th parameter for alpha using rgb()", async () => {
+      const result = await executeWithSchema(
+        "rgb-color",
+        "type",
+        `
+        variable c: Color.Rgb = rgb(255, 128, 64, 0.5);
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      expect((result as any).value.r.value).toBe(255);
+      expect((result as any).value.g.value).toBe(128);
+      expect((result as any).value.b.value).toBe(64);
+      expect((result as any).alpha).toBe(0.5);
+    });
+
+    it("should create color with rgba() initializer", async () => {
+      const result = await executeWithSchema(
+        "rgb-color",
+        "type",
+        `
+        variable c: Color.Rgb = rgba(200, 100, 50, 0.75);
+        c
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      expect((result as any).value.r.value).toBe(200);
+      expect((result as any).value.g.value).toBe(100);
+      expect((result as any).value.b.value).toBe(50);
+      expect((result as any).alpha).toBe(0.75);
+    });
+
+    it("should get alpha property", async () => {
+      const result = await executeWithSchema(
+        "rgb-color",
+        "type",
+        `
+        variable c: Color.Rgb = rgb(255, 0, 0, 0.3);
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.3);
+    });
+
+    it("should set alpha property", async () => {
+      const result = await executeWithSchema(
+        "rgb-color",
+        "type",
+        `
+        variable c: Color.Rgb = rgb(255, 0, 0);
+        c.alpha = 0.9;
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.9);
+    });
+
+    it("should handle alpha = 0 (fully transparent)", async () => {
+      const result = await executeWithSchema(
+        "rgb-color",
+        "type",
+        `
+        variable c: Color.Rgb = rgb(255, 0, 0, 0);
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0);
+    });
+
+    it("should handle alpha = 1 (fully opaque)", async () => {
+      const result = await executeWithSchema(
+        "rgb-color",
+        "type",
+        `
+        variable c: Color.Rgb = rgb(255, 0, 0, 1);
+        c.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(1);
+    });
+
+    it("should preserve alpha through HEX conversion", async () => {
+      const result = await executeWithSchema(
+        "rgb-color",
+        "type",
+        `
+        variable c: Color.Rgb = rgb(255, 0, 0, 0.5);
+        variable hex: Color.Hex = c.to.hex();
+        variable back: Color.Rgb = hex.to.rgb();
+        back.alpha
+      `,
+      );
+
+      expect((result as any).value).toBe(0.5);
+    });
+  });
 });

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

@@ -1,6 +1,6 @@
 // sRGB Color Initializer
 // Creates an sRGB color from normalized 0-1 values
-// Input: List of [r, g, b] values in 0-1 range
+// Input: List of [r, g, b] or [r, g, b, alpha] values in 0-1 range
 
 variable color_values: List = {input};
 variable output: Color.SRGB;
@@ -9,6 +9,11 @@ output.r = color_values.get(0);
 output.g = color_values.get(1);
 output.b = color_values.get(2);
 
+// Set alpha if provided as 4th parameter
+if (color_values.length() > 3) [
+  output.alpha = color_values.get(3);
+];
+
 return output;