@styleframe/core 1.0.1 → 1.0.2

package/src/tokens/ref.test.ts

@@ -1,430 +0,0 @@
-import { beforeEach, describe, expect, it } from "vitest";
-import type { Root, Selector } from "../types";
-import { createKeyframesFunction } from "./atRule";
-import { createRefFunction } from "./ref";
-import { createRoot } from "./root";
-import { createVariableFunction } from "./variable";
-
-describe("createRefFunction", () => {
-	let root: Root;
-	let selector: Selector;
-	let ref: ReturnType<typeof createRefFunction>;
-	let variable: ReturnType<typeof createVariableFunction>;
-	let keyframes: ReturnType<typeof createKeyframesFunction>;
-
-	beforeEach(() => {
-		root = createRoot();
-		selector = {
-			type: "selector",
-			query: ".test",
-			variables: [],
-			declarations: {},
-			children: [],
-		};
-		ref = createRefFunction(selector, root);
-		variable = createVariableFunction(selector, root);
-		keyframes = createKeyframesFunction(selector, root);
-	});
-
-	describe("basic reference creation", () => {
-		it("should create a reference from a variable instance", () => {
-			const colorPrimary = variable("color--primary", "#006cff");
-
-			const result = ref(colorPrimary);
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "color--primary",
-				fallback: undefined,
-			});
-		});
-
-		it("should create a reference from a variable name string", () => {
-			const result = ref("spacing--md");
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "spacing--md",
-				fallback: undefined,
-			});
-		});
-
-		it("should preserve the correct type", () => {
-			const result = ref("my-custom-var");
-
-			expect(result.type).toBe("reference");
-		});
-
-		it("should preserve generic type information", () => {
-			const colorVar = variable("color-primary", "#blue");
-			const result = ref(colorVar);
-
-			// Type should be preserved
-			expect(result.name).toBe("color-primary");
-		});
-	});
-
-	describe("fallback values", () => {
-		it("should create a reference with fallback from variable instance", () => {
-			const colorSecondary = variable("color--secondary", "#ff5733");
-
-			const result = ref(colorSecondary, "#cccccc");
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "color--secondary",
-				fallback: "#cccccc",
-			});
-		});
-
-		it("should create a reference with fallback from variable name", () => {
-			const result = ref("color--purple", "#ff5733");
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "color--purple",
-				fallback: "#ff5733",
-			});
-		});
-
-		it("should handle complex fallback values", () => {
-			const result = ref("spacing--xl", "calc(2rem + 10px)");
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "spacing--xl",
-				fallback: "calc(2rem + 10px)",
-			});
-		});
-
-		it("should handle empty string fallback", () => {
-			const result = ref("test-var", "");
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "test-var",
-				fallback: "",
-			});
-		});
-
-		it("should handle undefined fallback explicitly", () => {
-			const result = ref("test-var", undefined);
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "test-var",
-				fallback: undefined,
-			});
-		});
-	});
-
-	describe("context parameter handling", () => {
-		it("should work with root context", () => {
-			const refWithRootContext = createRefFunction(root, root);
-			const colorVar = variable("root-color", "#000");
-
-			const result = refWithRootContext(colorVar);
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "root-color",
-				fallback: undefined,
-			});
-		});
-
-		it("should work with selector context", () => {
-			const refWithSelectorContext = createRefFunction(selector, root);
-			const spacingVar = variable("selector-spacing", "1rem");
-
-			const result = refWithSelectorContext(spacingVar);
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "selector-spacing",
-				fallback: undefined,
-			});
-		});
-
-		it("should work with nested selector context", () => {
-			const nestedSelector: Selector = {
-				type: "selector",
-				query: "&:hover",
-				variables: [],
-				declarations: {},
-				children: [],
-			};
-
-			const refWithNestedContext = createRefFunction(nestedSelector, root);
-			const hoverVar = variable("hover-color", "#333");
-
-			const result = refWithNestedContext(hoverVar);
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "hover-color",
-				fallback: undefined,
-			});
-		});
-	});
-
-	describe("variable instance handling", () => {
-		it("should correctly identify variable instances using isVariable", () => {
-			const colorVar = variable("color-test", "#123456");
-
-			const result = ref(colorVar);
-
-			expect(result.name).toBe("color-test");
-			expect(result.type).toBe("reference");
-		});
-
-		it("should handle variables with different value types", () => {
-			const stringVar = variable("string-var", "value");
-			const numberVar = variable("number-var", "42px");
-			const complexVar = variable("complex-var", "calc(100% - 2rem)");
-
-			const stringRef = ref(stringVar);
-			const numberRef = ref(numberVar);
-			const complexRef = ref(complexVar);
-
-			expect(stringRef.name).toBe("string-var");
-			expect(numberRef.name).toBe("number-var");
-			expect(complexRef.name).toBe("complex-var");
-		});
-
-		it("should work with variables that have special characters in names", () => {
-			const specialVar = variable("color--primary-500", "#006cff");
-
-			const result = ref(specialVar);
-
-			expect(result.name).toBe("color--primary-500");
-		});
-	});
-
-	describe("string name handling", () => {
-		it("should handle various string patterns", () => {
-			const kebabCase = ref("font-family-sans");
-			const camelCase = ref("fontSize");
-			const snakeCase = ref("font_size");
-			const withNumbers = ref("size-12");
-			const withDashes = ref("color--primary--500");
-
-			expect(kebabCase.name).toBe("font-family-sans");
-			expect(camelCase.name).toBe("fontSize");
-			expect(snakeCase.name).toBe("font_size");
-			expect(withNumbers.name).toBe("size-12");
-			expect(withDashes.name).toBe("color--primary--500");
-		});
-
-		it("should handle empty string names", () => {
-			const result = ref("");
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "",
-				fallback: undefined,
-			});
-		});
-
-		it("should handle single character names", () => {
-			const result = ref("a");
-
-			expect(result).toEqual({
-				type: "reference",
-				name: "a",
-				fallback: undefined,
-			});
-		});
-	});
-
-	describe("reference chaining", () => {
-		it("should work with variables that reference other variables", () => {
-			const baseColor = variable("base-color", "#0066ff");
-			const primaryColor = variable("primary-color", ref(baseColor));
-
-			// Verify the primary variable contains a reference
-			expect(primaryColor.value).toEqual({
-				type: "reference",
-				name: "base-color",
-				fallback: undefined,
-			});
-		});
-
-		it("should support multiple levels of references", () => {
-			const baseColor = variable("base-color", "#0066ff");
-			const primaryColor = variable("primary-color", ref(baseColor));
-			const buttonColor = variable("button-color", ref(primaryColor));
-
-			expect(buttonColor.value).toEqual({
-				type: "reference",
-				name: "primary-color",
-				fallback: undefined,
-			});
-		});
-
-		it("should support references with fallbacks in chains", () => {
-			const baseColor = variable("base-color", "#0066ff");
-			const primaryColor = variable("primary-color", ref(baseColor, "#ff0000"));
-
-			expect(primaryColor.value).toEqual({
-				type: "reference",
-				name: "base-color",
-				fallback: "#ff0000",
-			});
-		});
-	});
-
-	describe("type safety and generic preservation", () => {
-		it("should preserve string literal types", () => {
-			const specificVar = variable("very-specific-name" as const, "value");
-			const result = ref(specificVar);
-
-			// This should maintain the literal type
-			expect(result.name).toBe("very-specific-name");
-		});
-
-		it("should work with union types", () => {
-			type ColorName = "primary" | "secondary" | "tertiary";
-
-			const colorRef1 = ref("primary" as ColorName);
-			const colorRef2 = ref("secondary" as ColorName);
-
-			expect(colorRef1.name).toBe("primary");
-			expect(colorRef2.name).toBe("secondary");
-		});
-
-		it("should maintain type information through function calls", () => {
-			const createColorRef = (name: string) => ref(name);
-
-			const result = createColorRef("dynamic-color");
-			expect(result.name).toBe("dynamic-color");
-		});
-	});
-
-	describe("edge cases", () => {
-		it("should handle variables with undefined names gracefully", () => {
-			// This would be a malformed variable, but we should handle it
-			const malformedVar = {
-				type: "variable" as const,
-				name: undefined as any,
-				value: "test",
-			};
-
-			const result = ref(malformedVar as any);
-
-			expect(result.name).toBeUndefined();
-			expect(result.type).toBe("reference");
-		});
-
-		it("should handle null fallback values", () => {
-			const result = ref("test-var", null as any);
-
-			expect(result.fallback).toBeNull();
-		});
-
-		it("should maintain object identity for repeated calls", () => {
-			const colorVar = variable("repeat-test", "#fff");
-
-			const ref1 = ref(colorVar);
-			const ref2 = ref(colorVar);
-
-			// Should create new objects each time
-			expect(ref1).not.toBe(ref2);
-			// But should be equal in content
-			expect(ref1).toEqual(ref2);
-		});
-	});
-
-	describe("real-world usage patterns", () => {
-		it("should support design token patterns", () => {
-			// Base tokens
-			const blue500 = variable("blue-500", "#3b82f6");
-			const blue600 = variable("blue-600", "#2563eb");
-
-			// Semantic tokens
-			const colorPrimary = variable("color-primary", ref(blue500));
-			const colorPrimaryHover = variable("color-primary-hover", ref(blue600));
-
-			expect(colorPrimary.value).toEqual({
-				type: "reference",
-				name: "blue-500",
-				fallback: undefined,
-			});
-
-			expect(colorPrimaryHover.value).toEqual({
-				type: "reference",
-				name: "blue-600",
-				fallback: undefined,
-			});
-		});
-
-		it("should work in selector declarations", () => {
-			const colorPrimary = variable("color-primary", "#006cff");
-			const spacingMd = variable("spacing-md", "1rem");
-
-			// Simulate selector usage
-			const declarations = {
-				backgroundColor: ref(colorPrimary),
-				padding: ref(spacingMd),
-				color: ref("text-color", "#000"),
-			};
-
-			expect(declarations.backgroundColor).toEqual({
-				type: "reference",
-				name: "color-primary",
-				fallback: undefined,
-			});
-
-			expect(declarations.padding).toEqual({
-				type: "reference",
-				name: "spacing-md",
-				fallback: undefined,
-			});
-
-			expect(declarations.color).toEqual({
-				type: "reference",
-				name: "text-color",
-				fallback: "#000",
-			});
-		});
-
-		it("should support conditional references", () => {
-			const isDark = false;
-			const lightColor = variable("light-bg", "#ffffff");
-			const darkColor = variable("dark-bg", "#000000");
-
-			const bgColor = isDark ? ref(darkColor) : ref(lightColor);
-
-			expect(bgColor).toEqual({
-				type: "reference",
-				name: "light-bg",
-				fallback: undefined,
-			});
-		});
-	});
-
-	describe("function context independence", () => {
-		it("should create independent functions for different contexts", () => {
-			const context1 = createRoot();
-			const context2 = {
-				type: "selector" as const,
-				query: ".test",
-				variables: [],
-				declarations: {},
-				children: [],
-			};
-
-			const ref1 = createRefFunction(context1, root);
-			const ref2 = createRefFunction(context2, root);
-
-			// Both should work independently
-			const result1 = ref1("test-var-1");
-			const result2 = ref2("test-var-2");
-
-			expect(result1.name).toBe("test-var-1");
-			expect(result2.name).toBe("test-var-2");
-
-			// And should be separate functions
-			expect(ref1).not.toBe(ref2);
-		});
-	});
-});

package/src/tokens/ref.ts

@@ -1,24 +0,0 @@
-import { isVariable } from "../typeGuards";
-import type { Container, Reference, Root, Variable } from "../types";
-
-export function createRefFunction(_parent: Container, _root: Root) {
-	return function ref<Name extends string>(
-		variable: Variable<Name> | Name,
-		fallback?: string,
-	): Reference<Name> {
-		if (isVariable(variable)) {
-			return {
-				type: "reference",
-				name: variable.name,
-				fallback,
-			};
-		}
-
-		// If a string name is passed, use it directly
-		return {
-			type: "reference",
-			name: variable,
-			fallback,
-		};
-	};
-}

package/src/tokens/root.test.ts

@@ -1,70 +0,0 @@
-import { describe, expect, it } from "vitest";
-import type { Root } from "../types";
-import { createRoot } from "./root";
-
-describe("createRoot", () => {
-	describe("basic functionality", () => {
-		it("should create a root object with correct type", () => {
-			const root = createRoot();
-
-			expect(root.type).toBe("root");
-		});
-
-		it("should create a root object with empty children array", () => {
-			const root = createRoot();
-
-			expect(root.children).toEqual([]);
-			expect(Array.isArray(root.children)).toBe(true);
-			expect(root.children).toHaveLength(0);
-		});
-
-		it("should create a root object with correct structure", () => {
-			const root = createRoot();
-
-			expect(root).toEqual({
-				type: "root",
-				declarations: {},
-				utilities: [],
-				modifiers: [],
-				recipes: [],
-				variables: [],
-				children: [],
-				themes: [],
-			});
-		});
-
-		it("should return a Root type", () => {
-			const root = createRoot();
-
-			// Type assertion to verify it matches Root interface
-			const typedRoot: Root = root;
-			expect(typedRoot).toBeDefined();
-		});
-	});
-
-	describe("multiple instances", () => {
-		it("should create independent root instances", () => {
-			const root1 = createRoot();
-			const root2 = createRoot();
-
-			expect(root1).not.toBe(root2);
-			expect(root1.children).not.toBe(root2.children);
-		});
-
-		it("should create fresh empty arrays for each instance", () => {
-			const root1 = createRoot();
-			const root2 = createRoot();
-
-			// Modify one instance
-			root1.variables.push({
-				type: "variable",
-				name: "test",
-				value: "test-value",
-			} as any);
-
-			// Other instance should remain unaffected
-			expect(root1.variables).toHaveLength(1);
-			expect(root2.variables).toHaveLength(0);
-		});
-	});
-});

package/src/tokens/root.ts

@@ -1,14 +0,0 @@
-import type { Root } from "../types";
-
-export function createRoot(): Root {
-	return {
-		type: "root",
-		declarations: {},
-		utilities: [],
-		modifiers: [],
-		recipes: [],
-		variables: [],
-		children: [],
-		themes: [],
-	};
-}