@fragments-sdk/viewer 0.2.1

package/src/__tests__/render-utils.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect } from "vitest";
+import {
+  serializeValue,
+  serializePropsToJsx,
+  findFragmentByName,
+  getAvailableComponents,
+  generateRenderScript,
+} from "../render-utils.js";
+
+describe("serializeValue", () => {
+  it("serializes null", () => {
+    expect(serializeValue(null)).toBe("null");
+  });
+
+  it("serializes undefined", () => {
+    expect(serializeValue(undefined)).toBe("undefined");
+  });
+
+  it("serializes strings with proper escaping", () => {
+    expect(serializeValue("hello")).toBe('"hello"');
+    expect(serializeValue("hello world")).toBe('"hello world"');
+    expect(serializeValue('with "quotes"')).toBe('"with \\"quotes\\""');
+  });
+
+  it("serializes numbers", () => {
+    expect(serializeValue(42)).toBe("42");
+    expect(serializeValue(3.14)).toBe("3.14");
+    expect(serializeValue(-10)).toBe("-10");
+    expect(serializeValue(0)).toBe("0");
+  });
+
+  it("serializes booleans", () => {
+    expect(serializeValue(true)).toBe("true");
+    expect(serializeValue(false)).toBe("false");
+  });
+
+  it("serializes arrays", () => {
+    expect(serializeValue([])).toBe("[]");
+    expect(serializeValue([1, 2, 3])).toBe("[1, 2, 3]");
+    expect(serializeValue(["a", "b"])).toBe('["a", "b"]');
+    expect(serializeValue([true, null, "x"])).toBe('[true, null, "x"]');
+  });
+
+  it("serializes objects", () => {
+    expect(serializeValue({})).toBe("{}");
+    expect(serializeValue({ a: 1 })).toBe('{"a": 1}');
+    expect(serializeValue({ name: "test", value: 42 })).toBe(
+      '{"name": "test", "value": 42}'
+    );
+  });
+
+  it("serializes nested structures", () => {
+    expect(serializeValue({ items: [1, 2], nested: { deep: true } })).toBe(
+      '{"items": [1, 2], "nested": {"deep": true}}'
+    );
+  });
+
+  it("returns undefined for functions", () => {
+    expect(serializeValue(() => {})).toBe("undefined");
+  });
+});
+
+describe("serializePropsToJsx", () => {
+  it("serializes empty props", () => {
+    expect(serializePropsToJsx({})).toBe("");
+  });
+
+  it("serializes string props as JSX attributes", () => {
+    expect(serializePropsToJsx({ variant: "primary" })).toBe(
+      'variant="primary"'
+    );
+    expect(serializePropsToJsx({ label: "Click me" })).toBe('label="Click me"');
+  });
+
+  it("serializes boolean props with JSX expression syntax", () => {
+    expect(serializePropsToJsx({ disabled: true })).toBe("disabled={true}");
+    expect(serializePropsToJsx({ checked: false })).toBe("checked={false}");
+  });
+
+  it("serializes number props with JSX expression syntax", () => {
+    expect(serializePropsToJsx({ count: 5 })).toBe("count={5}");
+    expect(serializePropsToJsx({ size: 24.5 })).toBe("size={24.5}");
+  });
+
+  it("serializes multiple props", () => {
+    const result = serializePropsToJsx({
+      variant: "danger",
+      disabled: false,
+      size: 16,
+    });
+    expect(result).toBe('variant="danger" disabled={false} size={16}');
+  });
+
+  it("filters out undefined props", () => {
+    expect(
+      serializePropsToJsx({
+        variant: "primary",
+        disabled: undefined,
+        label: "test",
+      })
+    ).toBe('variant="primary" label="test"');
+  });
+
+  it("serializes object props", () => {
+    expect(serializePropsToJsx({ style: { color: "red" } })).toBe(
+      'style={{"color": "red"}}'
+    );
+  });
+
+  it("serializes array props", () => {
+    expect(serializePropsToJsx({ items: [1, 2, 3] })).toBe("items={[1, 2, 3]}");
+  });
+});
+
+describe("findFragmentByName", () => {
+  const mockFragments = [
+    { path: "Button.fragment.tsx", fragment: { meta: { name: "Button" } } },
+    { path: "Card.fragment.tsx", fragment: { meta: { name: "Card" } } },
+    { path: "Alert.fragment.tsx", fragment: { meta: { name: "Alert" } } },
+  ];
+
+  it("finds fragment by exact name", () => {
+    const result = findFragmentByName("Button", mockFragments);
+    expect(result).toEqual({ name: "Button", path: "Button.fragment.tsx" });
+  });
+
+  it("finds fragment case-insensitively", () => {
+    expect(findFragmentByName("button", mockFragments)).toEqual({
+      name: "Button",
+      path: "Button.fragment.tsx",
+    });
+    expect(findFragmentByName("BUTTON", mockFragments)).toEqual({
+      name: "Button",
+      path: "Button.fragment.tsx",
+    });
+    expect(findFragmentByName("BuTtOn", mockFragments)).toEqual({
+      name: "Button",
+      path: "Button.fragment.tsx",
+    });
+  });
+
+  it("returns null for non-existent component", () => {
+    expect(findFragmentByName("NonExistent", mockFragments)).toBeNull();
+    expect(findFragmentByName("", mockFragments)).toBeNull();
+  });
+
+  it("handles empty fragments array", () => {
+    expect(findFragmentByName("Button", [])).toBeNull();
+  });
+});
+
+describe("getAvailableComponents", () => {
+  it("returns sorted list of component names", () => {
+    const fragments = [
+      { fragment: { meta: { name: "Zebra" } } },
+      { fragment: { meta: { name: "Alert" } } },
+      { fragment: { meta: { name: "Button" } } },
+    ];
+    expect(getAvailableComponents(fragments)).toEqual([
+      "Alert",
+      "Button",
+      "Zebra",
+    ]);
+  });
+
+  it("returns empty array for empty fragments", () => {
+    expect(getAvailableComponents([])).toEqual([]);
+  });
+});
+
+describe("generateRenderScript", () => {
+  it("generates script with correct import path", () => {
+    const script = generateRenderScript("/path/to/Button.fragment.tsx", "Button", {});
+    expect(script).toContain('import("/path/to/Button.fragment.tsx")');
+  });
+
+  it("generates script with empty props object when no props", () => {
+    const script = generateRenderScript("/path/to/Button.tsx", "Button", {});
+    expect(script).toContain("React.createElement(Component, {})");
+  });
+
+  it("generates script with props object", () => {
+    const script = generateRenderScript("/path/to/Button.tsx", "Button", {
+      variant: "danger",
+      disabled: true,
+    });
+    expect(script).toContain(
+      'React.createElement(Component, {"variant":"danger","disabled":true})'
+    );
+  });
+
+  it("handles children prop specially", () => {
+    const script = generateRenderScript("/path/to/Button.tsx", "Button", {
+      variant: "primary",
+      children: "Click me",
+    });
+    // Children should be passed as third argument, not in props object
+    expect(script).toContain(
+      'React.createElement(Component, {"variant":"primary"}, "Click me")'
+    );
+    // Children should NOT be in the props object
+    expect(script).not.toContain('"children":"Click me"');
+  });
+
+  it("handles children with other props", () => {
+    const script = generateRenderScript("/path/to/Alert.tsx", "Alert", {
+      severity: "warning",
+      children: "Warning message",
+      dismissible: true,
+    });
+    expect(script).toContain(
+      'React.createElement(Component, {"severity":"warning","dismissible":true}, "Warning message")'
+    );
+  });
+
+  it("includes React and ReactDOM imports", () => {
+    const script = generateRenderScript("/path/to/Button.tsx", "Button", {});
+    expect(script).toContain('import React from "react"');
+    expect(script).toContain('import { createRoot } from "react-dom/client"');
+  });
+
+  it("includes render ready signal", () => {
+    const script = generateRenderScript("/path/to/Button.tsx", "Button", {});
+    expect(script).toContain("window.__RENDER_READY__ = true");
+  });
+
+  it("includes error handling", () => {
+    const script = generateRenderScript("/path/to/Button.tsx", "Button", {});
+    expect(script).toContain("window.__RENDER_ERROR__");
+    expect(script).toContain('class="render-error"');
+  });
+});

package/src/__tests__/style-utils.test.ts

@@ -0,0 +1,404 @@
+import { describe, it, expect } from "vitest";
+import {
+  compareStyles,
+  compareStyleValue,
+  normalizeStyleValue,
+  compareColors,
+  parseColor,
+  compareNumericValues,
+} from "../style-utils.js";
+
+describe("parseColor", () => {
+  describe("hex colors", () => {
+    it("parses 6-digit hex color", () => {
+      expect(parseColor("#ff0000")).toEqual({ r: 255, g: 0, b: 0 });
+    });
+
+    it("parses lowercase hex color", () => {
+      expect(parseColor("#00ff00")).toEqual({ r: 0, g: 255, b: 0 });
+    });
+
+    it("parses mixed case hex color", () => {
+      expect(parseColor("#0000FF")).toEqual({ r: 0, g: 0, b: 255 });
+    });
+
+    it("parses hex color with values 0-255", () => {
+      expect(parseColor("#336699")).toEqual({ r: 51, g: 102, b: 153 });
+    });
+
+    it("returns null for 3-digit hex color", () => {
+      expect(parseColor("#f00")).toBeNull();
+    });
+  });
+
+  describe("rgb/rgba colors", () => {
+    it("parses rgb color", () => {
+      expect(parseColor("rgb(255, 0, 0)")).toEqual({ r: 255, g: 0, b: 0, a: 1 });
+    });
+
+    it("parses rgba color with alpha", () => {
+      expect(parseColor("rgba(255, 0, 0, 0.5)")).toEqual({
+        r: 255,
+        g: 0,
+        b: 0,
+        a: 0.5,
+      });
+    });
+
+    it("parses rgba color with alpha 0", () => {
+      expect(parseColor("rgba(0, 0, 0, 0)")).toEqual({
+        r: 0,
+        g: 0,
+        b: 0,
+        a: 0,
+      });
+    });
+
+    it("parses rgba color with alpha 1", () => {
+      expect(parseColor("rgba(100, 150, 200, 1)")).toEqual({
+        r: 100,
+        g: 150,
+        b: 200,
+        a: 1,
+      });
+    });
+
+    it("handles extra whitespace", () => {
+      expect(parseColor("rgb(  255 ,  128 ,  64  )")).toEqual({
+        r: 255,
+        g: 128,
+        b: 64,
+        a: 1,
+      });
+    });
+  });
+
+  describe("invalid colors", () => {
+    it("returns null for color keywords", () => {
+      expect(parseColor("red")).toBeNull();
+      expect(parseColor("transparent")).toBeNull();
+    });
+
+    it("returns null for hsl colors", () => {
+      expect(parseColor("hsl(0, 100%, 50%)")).toBeNull();
+    });
+
+    it("returns null for empty string", () => {
+      expect(parseColor("")).toBeNull();
+    });
+  });
+});
+
+describe("compareColors", () => {
+  it("matches identical hex colors", () => {
+    expect(compareColors("#ff0000", "#ff0000", 0)).toBe(true);
+  });
+
+  it("matches colors within tolerance", () => {
+    expect(compareColors("#ff0000", "#fe0000", 5)).toBe(true);
+    expect(compareColors("rgb(255, 0, 0)", "rgb(252, 0, 0)", 5)).toBe(true);
+  });
+
+  it("fails colors outside tolerance", () => {
+    expect(compareColors("#ff0000", "#f00000", 5)).toBe(false);
+    expect(compareColors("rgb(255, 0, 0)", "rgb(240, 0, 0)", 5)).toBe(false);
+  });
+
+  it("matches hex and rgba representations of same color", () => {
+    expect(compareColors("#ff0000", "rgba(255, 0, 0, 1)", 0)).toBe(true);
+  });
+
+  it("matches colors with similar alpha", () => {
+    expect(compareColors("rgba(255, 0, 0, 0.5)", "rgba(255, 0, 0, 0.52)", 5)).toBe(
+      true
+    );
+  });
+
+  it("fails colors with different alpha", () => {
+    expect(compareColors("rgba(255, 0, 0, 0.5)", "rgba(255, 0, 0, 0.7)", 5)).toBe(
+      false
+    );
+  });
+
+  it("falls back to string comparison for unparseable colors", () => {
+    expect(compareColors("red", "red", 0)).toBe(true);
+    expect(compareColors("red", "blue", 0)).toBe(false);
+  });
+});
+
+describe("compareNumericValues", () => {
+  it("matches identical values", () => {
+    expect(compareNumericValues("10px", "10px", 0)).toBe(true);
+  });
+
+  it("matches values within tolerance", () => {
+    expect(compareNumericValues("10px", "11px", 1)).toBe(true);
+    expect(compareNumericValues("10px", "9px", 1)).toBe(true);
+  });
+
+  it("fails values outside tolerance", () => {
+    expect(compareNumericValues("10px", "12px", 1)).toBe(false);
+  });
+
+  it("handles values without units", () => {
+    expect(compareNumericValues("10", "11", 1)).toBe(true);
+  });
+
+  it("handles decimal values", () => {
+    expect(compareNumericValues("10.5px", "11px", 1)).toBe(true);
+    expect(compareNumericValues("10.5px", "12px", 1)).toBe(false);
+  });
+
+  it("falls back to string comparison for non-numeric values", () => {
+    expect(compareNumericValues("auto", "auto", 0)).toBe(true);
+    expect(compareNumericValues("auto", "none", 0)).toBe(false);
+  });
+});
+
+describe("normalizeStyleValue", () => {
+  it("trims whitespace", () => {
+    expect(normalizeStyleValue("any", "  10px  ")).toBe("10px");
+  });
+
+  it("collapses multiple spaces", () => {
+    expect(normalizeStyleValue("any", "10px  20px")).toBe("10px 20px");
+  });
+
+  it('normalizes "none" boxShadow to empty string', () => {
+    expect(normalizeStyleValue("boxShadow", "none")).toBe("");
+  });
+
+  it('does not normalize "none" for other properties', () => {
+    expect(normalizeStyleValue("display", "none")).toBe("none");
+  });
+
+  it("normalizes transparent color to 'transparent'", () => {
+    expect(normalizeStyleValue("backgroundColor", "rgba(0, 0, 0, 0)")).toBe(
+      "transparent"
+    );
+    expect(normalizeStyleValue("borderColor", "rgba( 0 , 0 , 0 , 0 )")).toBe(
+      "transparent"
+    );
+  });
+});
+
+describe("compareStyleValue", () => {
+  describe("exact match", () => {
+    it("matches identical values", () => {
+      expect(compareStyleValue("fontFamily", "Inter", "Inter")).toBe(true);
+    });
+
+    it("matches after normalization", () => {
+      expect(compareStyleValue("fontFamily", " Inter ", "Inter")).toBe(true);
+    });
+  });
+
+  describe("color properties", () => {
+    it("uses color comparison for backgroundColor", () => {
+      expect(
+        compareStyleValue("backgroundColor", "#ff0000", "rgb(255, 0, 0)")
+      ).toBe(true);
+    });
+
+    it("uses color comparison for borderColor", () => {
+      expect(
+        compareStyleValue("borderColor", "#00ff00", "rgb(0, 255, 0)")
+      ).toBe(true);
+    });
+
+    it("allows tolerance in color comparison", () => {
+      expect(
+        compareStyleValue("backgroundColor", "#ff0000", "rgb(252, 0, 0)")
+      ).toBe(true);
+    });
+  });
+
+  describe("numeric properties", () => {
+    it("uses numeric comparison for borderWidth", () => {
+      expect(compareStyleValue("borderWidth", "1px", "2px")).toBe(true);
+      expect(compareStyleValue("borderWidth", "1px", "3px")).toBe(false);
+    });
+
+    it("uses numeric comparison for borderRadius", () => {
+      expect(compareStyleValue("borderRadius", "8px", "9px")).toBe(true);
+    });
+
+    it("uses numeric comparison for fontSize", () => {
+      expect(compareStyleValue("fontSize", "16px", "17px")).toBe(true);
+    });
+
+    it("uses numeric comparison for padding", () => {
+      expect(compareStyleValue("padding", "10px", "11px")).toBe(true);
+    });
+
+    it("uses numeric comparison for gap", () => {
+      expect(compareStyleValue("gap", "16px", "17px")).toBe(true);
+    });
+  });
+
+  describe("other properties", () => {
+    it("uses strict comparison for fontFamily", () => {
+      expect(compareStyleValue("fontFamily", "Inter", "Arial")).toBe(false);
+    });
+
+    it("uses strict comparison for fontWeight", () => {
+      expect(compareStyleValue("fontWeight", "400", "500")).toBe(false);
+    });
+
+    it("uses strict comparison for textAlign", () => {
+      expect(compareStyleValue("textAlign", "left", "center")).toBe(false);
+    });
+  });
+});
+
+describe("compareStyles", () => {
+  it("returns match true when all styles match", () => {
+    const figmaStyles = {
+      backgroundColor: "#ff0000",
+      fontSize: "16px",
+    };
+    const renderedStyles = {
+      backgroundColor: "rgb(255, 0, 0)",
+      fontSize: "16px",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    expect(result.match).toBe(true);
+    expect(result.properties).toHaveLength(2);
+    expect(result.properties.every((p) => p.match)).toBe(true);
+  });
+
+  it("returns match false when some styles differ", () => {
+    const figmaStyles = {
+      backgroundColor: "#ff0000",
+      fontSize: "16px",
+    };
+    const renderedStyles = {
+      backgroundColor: "rgb(0, 255, 0)",
+      fontSize: "16px",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    expect(result.match).toBe(false);
+    expect(result.properties.find((p) => p.property === "backgroundColor")?.match).toBe(
+      false
+    );
+    expect(result.properties.find((p) => p.property === "fontSize")?.match).toBe(
+      true
+    );
+  });
+
+  it("only compares properties present in figmaStyles", () => {
+    const figmaStyles = {
+      backgroundColor: "#ff0000",
+    };
+    const renderedStyles = {
+      backgroundColor: "rgb(255, 0, 0)",
+      fontSize: "16px",
+      fontFamily: "Inter",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    expect(result.properties).toHaveLength(1);
+    expect(result.properties[0].property).toBe("backgroundColor");
+  });
+
+  it("marks missing rendered styles as not matching", () => {
+    const figmaStyles = {
+      backgroundColor: "#ff0000",
+      borderRadius: "8px",
+    };
+    const renderedStyles = {
+      backgroundColor: "rgb(255, 0, 0)",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    const borderRadius = result.properties.find(
+      (p) => p.property === "borderRadius"
+    );
+    expect(borderRadius?.rendered).toBe("(not set)");
+    expect(borderRadius?.match).toBe(false);
+  });
+
+  it("returns cleaned figmaStyles object", () => {
+    const figmaStyles = {
+      backgroundColor: "#ff0000",
+      fontSize: undefined,
+      fontFamily: "Inter",
+    };
+    const renderedStyles = {
+      backgroundColor: "rgb(255, 0, 0)",
+      fontFamily: "Inter",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    expect(result.figmaStyles).toEqual({
+      backgroundColor: "#ff0000",
+      fontFamily: "Inter",
+    });
+    expect(result.figmaStyles.fontSize).toBeUndefined();
+  });
+
+  it("preserves renderedStyles in output", () => {
+    const figmaStyles = {
+      backgroundColor: "#ff0000",
+    };
+    const renderedStyles = {
+      backgroundColor: "rgb(255, 0, 0)",
+      fontSize: "16px",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    expect(result.renderedStyles).toBe(renderedStyles);
+  });
+
+  it("handles empty figmaStyles", () => {
+    const figmaStyles = {};
+    const renderedStyles = {
+      backgroundColor: "rgb(255, 0, 0)",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    expect(result.match).toBe(true);
+    expect(result.properties).toHaveLength(0);
+  });
+
+  it("compares all standard properties when present", () => {
+    const figmaStyles = {
+      backgroundColor: "#ff0000",
+      borderColor: "#000000",
+      borderWidth: "1px",
+      borderRadius: "4px",
+      fontFamily: "Inter",
+      fontSize: "16px",
+      fontWeight: "400",
+      lineHeight: "24px",
+      letterSpacing: "-0.5px",
+      textAlign: "left",
+      boxShadow: "0px 4px 8px rgba(0, 0, 0, 0.25)",
+      padding: "16px",
+      gap: "8px",
+      opacity: "0.9",
+    };
+    const renderedStyles = {
+      backgroundColor: "rgb(255, 0, 0)",
+      borderColor: "rgb(0, 0, 0)",
+      borderWidth: "1px",
+      borderRadius: "4px",
+      fontFamily: "Inter",
+      fontSize: "16px",
+      fontWeight: "400",
+      lineHeight: "24px",
+      letterSpacing: "-0.5px",
+      textAlign: "left",
+      boxShadow: "0px 4px 8px rgba(0, 0, 0, 0.25)",
+      padding: "16px",
+      gap: "8px",
+      opacity: "0.9",
+    };
+
+    const result = compareStyles(figmaStyles, renderedStyles);
+    expect(result.match).toBe(true);
+    expect(result.properties).toHaveLength(14);
+  });
+});

package/src/app/index.ts

@@ -0,0 +1 @@
+export { App as ViewerApp } from '../components/App.js';

package/src/assets/fragments-logo.ts

@@ -0,0 +1,4 @@
+// Inline base64 data URL for the Fragments logo PNG.
+// Vite cannot resolve static asset imports from node_modules,
+// so we embed the image directly to avoid resolution errors.
+export const fragmentsLogo = "data:image/png;base64,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";