@tokens-studio/tokenscript-schemas 0.0.11 → 0.0.13

package/src/schemas/functions/invert/unit.test.ts

@@ -0,0 +1,216 @@
+import { executeWithSchema, getBundledSchema } from "@tests/helpers/schema-test-utils";
+import { describe, expect, it } from "vitest";
+import type { FunctionSpecification } from "@/bundler/types";
+
+describe("Invert Function Schema", () => {
+  describe("Schema Definition", () => {
+    it("should have correct schema structure", async () => {
+      const schema = (await getBundledSchema("invert", "function")) as FunctionSpecification;
+
+      expect(schema.name).toBe("Invert Color");
+      expect(schema.type).toBe("function");
+      expect(schema.description).toBe(
+        "Inverts a color by inverting each RGB channel (R' = 255 - R, G' = 255 - G, B' = 255 - B).",
+      );
+      expect(schema.keyword).toBe("invert");
+      expect(schema.input).toBeDefined();
+      expect(schema.input?.type).toBe("object");
+      expect(schema.input?.properties).toHaveProperty("color");
+    });
+
+    it("should have script defined", async () => {
+      const schema = (await getBundledSchema("invert", "function")) as FunctionSpecification;
+
+      expect(schema.script).toBeDefined();
+      expect(schema.script.script).toBeTruthy();
+      expect(schema.script.script).not.toContain("./");
+    });
+
+    it("should have requirements", async () => {
+      const schema = (await getBundledSchema("invert", "function")) as FunctionSpecification;
+
+      expect(schema.requirements).toBeDefined();
+      expect(schema.requirements).toContain(
+        "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/rgb-color/0/",
+      );
+    });
+  });
+
+  describe("Function Execution", () => {
+    it("should invert RGB color", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable original: Color.Rgb = rgb(255, 128, 64);
+        invert(original)
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      expect((result as any).value.r.value).toBe(0);
+      expect((result as any).value.g.value).toBe(127);
+      expect((result as any).value.b.value).toBe(191);
+    });
+
+    it("should invert HEX color", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable original: Color.Hex = #ff8040;
+        invert(original)
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      expect((result as any).value.r.value).toBe(0);
+      expect((result as any).value.g.value).toBe(127);
+      expect((result as any).value.b.value).toBe(191);
+    });
+
+    it("should invert black to white", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable black: Color.Hex = #000000;
+        invert(black)
+      `,
+      );
+
+      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(255);
+      expect((result as any).value.b.value).toBe(255);
+    });
+
+    it("should invert white to black", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable white: Color.Hex = #ffffff;
+        invert(white)
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      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 invert gray (127.5 rounds to 128)", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable gray: Color.Hex = #7f7f7f;
+        invert(gray)
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      expect((result as any).value.r.value).toBe(128);
+      expect((result as any).value.g.value).toBe(128);
+      expect((result as any).value.b.value).toBe(128);
+    });
+  });
+
+  describe("Round-trip Inversions", () => {
+    it("should return to original color when inverted twice", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable original: Color.Hex = #3498db;
+        variable inverted: Color.Rgb = invert(original);
+        variable backToOriginal: Color.Rgb = invert(inverted);
+        backToOriginal.to.hex()
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Hex");
+      expect(result?.toString()).toBe("#3498db");
+    });
+
+    it("should handle double inversion of RGB color", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable original: Color.Rgb = rgb(100, 150, 200);
+        variable inverted: Color.Rgb = invert(original);
+        variable backToOriginal: Color.Rgb = invert(inverted);
+        backToOriginal
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      expect((result as any).value.r.value).toBe(100);
+      expect((result as any).value.g.value).toBe(150);
+      expect((result as any).value.b.value).toBe(200);
+    });
+  });
+
+  describe("Edge Cases", () => {
+    it("should handle pure red", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable red: Color.Hex = #ff0000;
+        invert(red)
+      `,
+      );
+
+      expect(result?.constructor.name).toBe("ColorSymbol");
+      expect((result as any).subType).toBe("Rgb");
+      expect((result as any).value.r.value).toBe(0);
+      expect((result as any).value.g.value).toBe(255);
+      expect((result as any).value.b.value).toBe(255);
+    });
+
+    it("should handle pure green", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable green: Color.Hex = #00ff00;
+        invert(green)
+      `,
+      );
+
+      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(0);
+      expect((result as any).value.b.value).toBe(255);
+    });
+
+    it("should handle pure blue", async () => {
+      const result = await executeWithSchema(
+        "invert",
+        "function",
+        `
+        variable blue: Color.Hex = #0000ff;
+        invert(blue)
+      `,
+      );
+
+      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(255);
+      expect((result as any).value.b.value).toBe(0);
+    });
+  });
+});

package/src/schemas/functions/is_cool/is-cool.tokenscript

@@ -0,0 +1,41 @@
+// Is Cool Color
+// Determines if a color is perceptually cool
+//
+// Cool colors are associated with:
+// - Water, ice, sky
+// - Calm, professional, trustworthy feelings
+// - Receding visual perception (appear further away)
+//
+// OKLCH hue ranges:
+// - Cool: 130-320° (yellow-green through purple)
+// - Includes: green, cyan, blue, purple
+//
+// Achromatic colors (low chroma) are considered cool/neutral
+
+variable input: List = {input};
+variable color: Color.OKLCH = input.get(0).to.oklch();
+
+// Get hue and chroma
+variable h: Number = color.h;
+variable c: Number = color.c;
+
+// Achromatic colors (very low chroma) are considered cool/neutral
+if (c < 0.02) [
+    return true;
+];
+
+// Normalize hue to 0-360
+if (h < 0) [ h = h + 360; ];
+if (h >= 360) [ h = h - 360; ];
+
+// Cool hue range: 130-320° (green through purple)
+variable is_cool: Boolean = false;
+
+if (h > 130) [
+    if (h < 320) [
+        is_cool = true;
+    ];
+];
+
+return is_cool;
+

package/src/schemas/functions/is_cool/schema.json

@@ -0,0 +1,20 @@
+{
+  "name": "Is Cool",
+  "type": "function",
+  "description": "Checks if a color is perceptually cool. Cool colors have hues in the green-blue-purple range (roughly 130-320° in OKLCH). Returns true for cool colors (green, cyan, blue, purple), false for warm colors. Achromatic colors are considered neutral/cool.",
+  "keyword": "is_cool",
+  "input": {
+    "type": "object",
+    "properties": {
+      "color": {
+        "type": "color",
+        "description": "Color to check"
+      }
+    }
+  },
+  "script": {
+    "type": "/api/v1/core/tokenscript/0/",
+    "script": "./is-cool.tokenscript"
+  },
+  "requirements": ["/api/v1/core/oklch-color/0/"]
+}

package/src/schemas/functions/is_cool/unit.test.ts

@@ -0,0 +1,189 @@
+import { executeWithSchema } from "@tests/helpers/schema-test-utils";
+import { describe, expect, it } from "vitest";
+
+describe("Is Cool Function", () => {
+  describe("Schema Definition", () => {
+    it("should have correct schema structure", async () => {
+      const { getBundledSchema } = await import("@tests/helpers/schema-test-utils");
+      const schema = await getBundledSchema("is_cool", "function");
+
+      expect(schema.name).toBe("Is Cool");
+      expect(schema.type).toBe("function");
+      expect((schema as any).keyword).toBe("is_cool");
+    });
+  });
+
+  describe("Cool Colors", () => {
+    it("should return true for blue", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0; c.g = 0; c.b = 1;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(true);
+    });
+
+    it("should return true for green", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0; c.g = 1; c.b = 0;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(true);
+    });
+
+    it("should return true for cyan", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0; c.g = 1; c.b = 1;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(true);
+    });
+
+    it("should return true for purple", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0.5; c.g = 0; c.b = 1;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(true);
+    });
+  });
+
+  describe("Warm Colors", () => {
+    it("should return false for red", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 1; c.g = 0; c.b = 0;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(false);
+    });
+
+    it("should return false for orange", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 1; c.g = 0.5; c.b = 0;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(false);
+    });
+
+    it("should return false for yellow", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 1; c.g = 1; c.b = 0;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(false);
+    });
+  });
+
+  describe("Achromatic Colors", () => {
+    it("should return true for white (neutral treated as cool)", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 1; c.g = 1; c.b = 1;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(true);
+    });
+
+    it("should return true for black (neutral treated as cool)", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0; c.g = 0; c.b = 0;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(true);
+    });
+
+    it("should return true for gray (neutral treated as cool)", async () => {
+      const result = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0.5; c.g = 0.5; c.b = 0.5;
+        is_cool(c)
+        `,
+      );
+
+      expect(result.value).toBe(true);
+    });
+  });
+
+  describe("Complementary to is_warm", () => {
+    it("is_cool and is_warm should be mutually exclusive for chromatic colors", async () => {
+      // Blue is cool, not warm
+      const coolResult = await executeWithSchema(
+        "is_cool",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0; c.g = 0; c.b = 1;
+        is_cool(c)
+        `,
+      );
+
+      const warmResult = await executeWithSchema(
+        "is_warm",
+        "function",
+        `
+        variable c: Color.SRGB;
+        c.r = 0; c.g = 0; c.b = 1;
+        is_warm(c)
+        `,
+      );
+
+      expect(coolResult.value).toBe(true);
+      expect(warmResult.value).toBe(false);
+    });
+  });
+});

package/src/schemas/functions/is_dark/is-dark.tokenscript

@@ -0,0 +1,16 @@
+// Check if a color is perceptually dark
+// Uses OKLCH lightness for accurate perception matching
+//
+// Returns: true if L <= threshold, false otherwise
+// Default threshold: 0.6 (slightly above middle)
+
+variable input: List = {input};
+variable color: Color.OKLCH = input.get(0).to.oklch();
+
+variable threshold: Number = 0.6;
+if (input.length() > 1) [
+    threshold = input.get(1);
+];
+
+return color.l <= threshold;
+

package/src/schemas/functions/is_dark/schema.json

@@ -0,0 +1,24 @@
+{
+  "name": "Is Dark",
+  "type": "function",
+  "description": "Returns true if a color is perceptually dark (lightness <= threshold). Uses OKLCH lightness for perceptual accuracy. Default threshold is 0.6.",
+  "keyword": "is_dark",
+  "input": {
+    "type": "object",
+    "properties": {
+      "color": {
+        "type": "color",
+        "description": "The color to check"
+      },
+      "threshold": {
+        "type": "number",
+        "description": "Lightness threshold (0-1). Default is 0.6"
+      }
+    }
+  },
+  "script": {
+    "type": "/api/v1/core/tokenscript/0/",
+    "script": "./is-dark.tokenscript"
+  },
+  "requirements": ["/api/v1/core/oklch-color/0/"]
+}

package/src/schemas/functions/is_dark/unit.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Unit tests for the Is Dark function
+ * Checks if a color is perceptually dark
+ */
+
+import { executeWithSchema, getBundledSchema } from "@tests/helpers/schema-test-utils";
+import { describe, expect, it } from "vitest";
+import type { FunctionSpecification } from "@/bundler/types";
+
+describe("Is Dark Function", () => {
+  describe("Schema Definition", () => {
+    it("should have correct schema structure", async () => {
+      const schema = (await getBundledSchema("is_dark", "function")) as FunctionSpecification;
+
+      expect(schema.name).toBe("Is Dark");
+      expect(schema.type).toBe("function");
+      expect(schema.keyword).toBe("is_dark");
+    });
+  });
+
+  describe("Function Execution", () => {
+    it("should return true for black", async () => {
+      const result = await executeWithSchema(
+        "is_dark",
+        "function",
+        `
+        variable black: Color.SRGB;
+        black.r = 0; black.g = 0; black.b = 0;
+        is_dark(black)
+        `,
+      );
+
+      expect(result).toBeDefined();
+      const isDark = (result as any).value ?? result;
+      expect(isDark).toBe(true);
+    });
+
+    it("should return false for white", async () => {
+      const result = await executeWithSchema(
+        "is_dark",
+        "function",
+        `
+        variable white: Color.SRGB;
+        white.r = 1; white.g = 1; white.b = 1;
+        is_dark(white)
+        `,
+      );
+
+      expect(result).toBeDefined();
+      const isDark = (result as any).value ?? result;
+      expect(isDark).toBe(false);
+    });
+
+    it("should return true for dark navy", async () => {
+      const result = await executeWithSchema(
+        "is_dark",
+        "function",
+        `
+        variable navy: Color.SRGB;
+        navy.r = 0.05; navy.g = 0.05; navy.b = 0.2;
+        is_dark(navy)
+        `,
+      );
+
+      expect(result).toBeDefined();
+      const isDark = (result as any).value ?? result;
+      expect(isDark).toBe(true);
+    });
+
+    it("should be opposite of is_light", async () => {
+      const result = await executeWithSchema(
+        "is_dark",
+        "function",
+        `
+        variable gray: Color.SRGB;
+        gray.r = 0.3; gray.g = 0.3; gray.b = 0.3;
+        is_dark(gray)
+        `,
+      );
+
+      expect(result).toBeDefined();
+      // Dark gray should be dark
+      const isDark = (result as any).value ?? result;
+      expect(isDark).toBe(true);
+    });
+  });
+});

package/src/schemas/functions/is_light/is-light.tokenscript

@@ -0,0 +1,16 @@
+// Check if a color is perceptually light
+// Uses OKLCH lightness for accurate perception matching
+//
+// Returns: true if L > threshold, false otherwise
+// Default threshold: 0.6 (slightly above middle)
+
+variable input: List = {input};
+variable color: Color.OKLCH = input.get(0).to.oklch();
+
+variable threshold: Number = 0.6;
+if (input.length() > 1) [
+    threshold = input.get(1);
+];
+
+return color.l > threshold;
+

package/src/schemas/functions/is_light/schema.json

@@ -0,0 +1,24 @@
+{
+  "name": "Is Light",
+  "type": "function",
+  "description": "Returns true if a color is perceptually light (lightness > threshold). Uses OKLCH lightness for perceptual accuracy. Default threshold is 0.6.",
+  "keyword": "is_light",
+  "input": {
+    "type": "object",
+    "properties": {
+      "color": {
+        "type": "color",
+        "description": "The color to check"
+      },
+      "threshold": {
+        "type": "number",
+        "description": "Lightness threshold (0-1). Default is 0.6"
+      }
+    }
+  },
+  "script": {
+    "type": "/api/v1/core/tokenscript/0/",
+    "script": "./is-light.tokenscript"
+  },
+  "requirements": ["/api/v1/core/oklch-color/0/"]
+}