@styleframe/core 1.0.1 → 1.0.2

package/src/tokens/utility.ts

@@ -1,92 +0,0 @@
-import type {
-	Container,
-	ModifierFactory,
-	Root,
-	TokenValue,
-	Utility,
-	UtilityCallbackFn,
-	UtilityCreatorFn,
-	UtilityFactory,
-} from "../types";
-import {
-	createDeclarationsCallbackContext,
-	parseDeclarationsBlock,
-} from "./declarations";
-import { applyModifiers, combineKeys } from "./modifier";
-
-export function createModifiedUtilityInstances(
-	baseInstance: Utility,
-	availableModifiers: ModifierFactory[],
-	root: Root,
-): Utility[] {
-	const modifierKeys = availableModifiers.map((modifier) => modifier.key);
-	const modifierKeyCombinations = combineKeys(modifierKeys);
-
-	return modifierKeyCombinations.map((combination) => {
-		const modifiers = new Map<string, ModifierFactory>();
-
-		for (const modifierKey of combination) {
-			const modifier = availableModifiers.find((modifier) =>
-				modifier.key.includes(modifierKey),
-			);
-			if (modifier) modifiers.set(modifierKey, modifier);
-		}
-
-		return applyModifiers(baseInstance, root, modifiers);
-	});
-}
-
-export function createUtilityFunction(parent: Container, root: Root) {
-	return function utility<Name extends string>(
-		name: Name,
-		factory: UtilityCallbackFn,
-	): UtilityCreatorFn {
-		const factoryInstance: UtilityFactory<Name> = {
-			type: "utility",
-			name,
-			factory,
-		};
-
-		root.utilities.push(factoryInstance);
-
-		return (
-			entries: Record<string, TokenValue>,
-			modifiers: ModifierFactory[] = [],
-		) => {
-			for (const [key, value] of Object.entries(entries)) {
-				const instance: Utility<Name> = {
-					type: "utility",
-					name,
-					value: key,
-					declarations: {},
-					variables: [],
-					children: [],
-					modifiers: [],
-				};
-
-				const callbackContext = createDeclarationsCallbackContext(
-					instance,
-					root,
-				);
-
-				instance.declarations =
-					factory({
-						...callbackContext,
-						value,
-					}) ?? {};
-
-				parseDeclarationsBlock(instance.declarations, callbackContext);
-
-				// Store the utility value on the instance
-				parent.children.push(instance);
-
-				// Create modified variants for this specific value
-				if (modifiers.length > 0) {
-					parent.children.push(
-						...createModifiedUtilityInstances(instance, modifiers, root),
-					);
-				}
-			}
-		};
-	};
-}

package/src/tokens/variable.test.ts

@@ -1,235 +0,0 @@
-import type { Reference, Root, Selector, Variable } from "../types";
-import { createRoot } from "./root";
-import { createSelectorFunction } from "./selector";
-import { createVariableFunction } from "./variable";
-
-describe("createVariableFunction", () => {
-	let root: Root;
-	let variable: ReturnType<typeof createVariableFunction>;
-	let selector: ReturnType<typeof createSelectorFunction>;
-
-	beforeEach(() => {
-		root = createRoot();
-		variable = createVariableFunction(root, root);
-		selector = createSelectorFunction(root, root);
-	});
-
-	describe("basic variable creation", () => {
-		it("should create a new variable with correct properties", () => {
-			const result = variable("primary-color", "#007bff");
-
-			expect(result).toEqual({
-				type: "variable",
-				name: "primary-color",
-				value: "#007bff",
-			});
-		});
-
-		it("should add the variable to root declarations", () => {
-			const result = variable("spacing", "1rem");
-
-			expect(root.variables).toHaveLength(1);
-			expect(root.variables[0]).toBe(result);
-		});
-	});
-
-	describe("default behavior", () => {
-		describe("when false", () => {
-			it("should update existing variable value when default is false", () => {
-				const first = variable("border-width", "1px", { default: true });
-				const second = variable("border-width", "2px", { default: false });
-
-				expect(second).toBe(first); // Same instance
-				expect(second.value).toBe("2px"); // Updated value
-				expect(root.variables).toHaveLength(1);
-			});
-
-			it("should create new variable if none exists with default: false", () => {
-				const result = variable("line-height", "1.5", { default: false });
-
-				expect(result.value).toBe("1.5");
-				expect(root.variables).toHaveLength(1);
-			});
-		});
-
-		describe("when true", () => {
-			it("should return existing variable when default is true", () => {
-				const first = variable("color", "red");
-				const second = variable("color", "blue", { default: true }); // Should return first, not create new
-
-				expect(second).toBe(first);
-				expect(second.value).toBe("red");
-				expect(root.variables).toHaveLength(1);
-			});
-
-			it("should return existing variable with explicit default: true", () => {
-				const first = variable("font-size", "16px", { default: true });
-				const second = variable("font-size", "18px", { default: true });
-
-				expect(second).toBe(first);
-				expect(second.value).toBe("16px");
-				expect(root.variables).toHaveLength(1);
-			});
-
-			it("should create new variable if none exists with default: true", () => {
-				const result = variable("margin", "10px", { default: true });
-
-				expect(result.value).toBe("10px");
-				expect(root.variables).toHaveLength(1);
-			});
-		});
-	});
-
-	describe("multiple variables", () => {
-		it("should handle multiple different variables", () => {
-			const color = variable("color", "blue");
-			const spacing = variable("spacing", "8px");
-			const fontSize = variable("font-size", "14px");
-
-			expect(root.variables).toHaveLength(3);
-			expect(root.variables).toContain(color);
-			expect(root.variables).toContain(spacing);
-			expect(root.variables).toContain(fontSize);
-		});
-
-		it("should find correct existing variable among multiple", () => {
-			const color = variable("color", "red");
-			const spacing = variable("spacing", "10px");
-			const fontSize = variable("font-size", "16px");
-
-			// Try to override the middle variable
-			const updatedSpacing = variable("spacing", "20px", { default: false });
-
-			expect(updatedSpacing).toBe(spacing);
-			expect(updatedSpacing.value).toBe("20px");
-			expect(root.variables).toHaveLength(3);
-		});
-	});
-
-	describe("working with references", () => {
-		it("should handle reference token values", () => {
-			const reference: Reference = {
-				type: "reference",
-				name: "base-color",
-				fallback: "#000000",
-			};
-
-			const result = variable("ref-color", reference);
-
-			expect(result.value).toEqual(reference);
-		});
-	});
-
-	describe("working with selectors", () => {
-		it("should work when root is a selector", () => {
-			const selectorInstance = selector(".test", {});
-
-			const selectorVariable = createVariableFunction(selectorInstance, root);
-			const result = selectorVariable("nested-var", "50px");
-
-			expect(result.name).toBe("nested-var");
-			expect(selectorInstance.variables).toHaveLength(1);
-			expect(selectorInstance.variables[0]).toBe(result);
-		});
-	});
-
-	describe("edge cases", () => {
-		it("should handle empty string values", () => {
-			const result = variable("empty", "");
-			expect(result.value).toBe("");
-		});
-
-		it("should handle null values", () => {
-			const result = variable("null-value", null);
-			expect(result.value).toBe(null);
-		});
-
-		it("should handle undefined values", () => {
-			const result = variable("undefined-value", undefined);
-			expect(result.value).toBe(undefined);
-		});
-
-		it("should handle numeric values", () => {
-			const result = variable("numeric", 42);
-			expect(result.value).toBe(42);
-		});
-
-		it("should handle boolean values", () => {
-			const result = variable("boolean", true);
-			expect(result.value).toBe(true);
-		});
-	});
-
-	describe("type safety", () => {
-		it("should maintain type information for variable name", () => {
-			const result = variable("test-var", "100px");
-
-			// Type assertion to verify the generic type is preserved
-			const typedResult: Variable<"test-var"> = result;
-			expect(typedResult.name).toBe("test-var");
-		});
-
-		it("should preserve generic type parameter", () => {
-			const result = variable("typed-var", "test-value");
-
-			// This should compile without type errors
-			const name: "typed-var" = result.name;
-			expect(name).toBe("typed-var");
-		});
-
-		it("should work with different string literal types", () => {
-			const colorVar = variable("color-primary", "#ff0000");
-			const spacingVar = variable("spacing-lg", "2rem");
-
-			expect(colorVar.name).toBe("color-primary");
-			expect(spacingVar.name).toBe("spacing-lg");
-		});
-	});
-
-	describe("accepting variable instance as name", () => {
-		let root: Root;
-		let variable: ReturnType<typeof createVariableFunction>;
-
-		beforeEach(() => {
-			root = createRoot();
-			variable = createVariableFunction(root, root);
-		});
-
-		it("should update existing variable when passing variable instance", () => {
-			const first = variable("v", "a");
-			const updated = variable(first, "b");
-
-			expect(updated).toBe(first);
-			expect(updated.value).toBe("b");
-			expect(root.variables).toHaveLength(1);
-		});
-
-		it("should respect default: true when passing variable instance", () => {
-			const first = variable("color", "red");
-			const result = variable(first, "blue", { default: true });
-
-			expect(result).toBe(first);
-			expect(first.value).toBe("red");
-			expect(root.variables).toHaveLength(1);
-		});
-
-		it("should create variable in new container when target from different parent", () => {
-			const base = variable("spacing", "8px");
-			const selectorInstance = selector(".x", {});
-			const selectorVariable = createVariableFunction(selectorInstance, root);
-			const result = selectorVariable(base, "12px");
-
-			expect(result.name).toBe("spacing");
-			expect(selectorInstance.variables).toHaveLength(1);
-			expect(selectorInstance.variables[0]).toBe(result);
-		});
-
-		it("should maintain type information when passing variable instance", () => {
-			const base = variable("typed-var", "x");
-			const result = variable(base, "y");
-
-			const typedResult: Variable<"typed-var"> = result;
-			expect(typedResult.name).toBe("typed-var");
-		});
-	});
-});

package/src/tokens/variable.ts

@@ -1,42 +0,0 @@
-import type { Container, Root, TokenValue, Variable } from "../types";
-
-export function createVariableFunction(parent: Container, _root: Root) {
-	return function variable<Name extends string>(
-		nameOrInstance: Name | Variable<Name>,
-		value: TokenValue,
-		options: {
-			default: boolean;
-		} = {
-			default: false,
-		},
-	): Variable<Name> {
-		const name = (
-			typeof nameOrInstance === "string" ? nameOrInstance : nameOrInstance.name
-		) as Name;
-
-		const existingVariable = parent.variables.find(
-			(child) => child.name === name,
-		) as Variable<Name> | undefined;
-
-		// If default is true and the variable exists, return existing
-		if (options.default && existingVariable) {
-			return existingVariable;
-		}
-
-		// If default is false and the variable exists, update the value
-		if (existingVariable) {
-			existingVariable.value = value;
-			return existingVariable;
-		}
-
-		// Create a new variable
-		const instance: Variable<Name> = {
-			type: "variable",
-			name,
-			value,
-		};
-
-		parent.variables.push(instance);
-		return instance;
-	};
-}

package/src/typeGuards.test.ts

@@ -1,33 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { isTokenValue } from "./typeGuards";
-import type { Reference, CSS } from "./types";
-
-describe("isTokenValue", () => {
-	it("should return true for primitive token values", () => {
-		expect(isTokenValue("string")).toBe(true);
-		expect(isTokenValue(42)).toBe(true);
-		expect(isTokenValue(true)).toBe(true);
-		expect(isTokenValue(null)).toBe(true);
-	});
-
-	it("should return true for Reference objects", () => {
-		const ref: Reference = { type: "reference", name: "color" };
-		expect(isTokenValue(ref)).toBe(true);
-	});
-
-	it("should return true for CSS objects", () => {
-		const css: CSS = { type: "css", value: ["color", "red"] };
-		expect(isTokenValue(css)).toBe(true);
-	});
-
-	it("should return true for arrays of token values", () => {
-		const ref: Reference = { type: "reference", name: "size" };
-		const css: CSS = { type: "css", value: ["margin", "0"] };
-		expect(isTokenValue(["foo", ref, css])).toBe(true);
-	});
-
-	it("should return false for invalid values", () => {
-		expect(isTokenValue({})).toBe(false);
-		expect(isTokenValue(["foo", {}])).toBe(false);
-	});
-});

package/src/typeGuards.ts

@@ -1,98 +0,0 @@
-import type {
-	AtRule,
-	Container,
-	CSS,
-	ModifierFactory,
-	PrimitiveTokenValue,
-	Reference,
-	Root,
-	Selector,
-	Theme,
-	TokenType,
-	TokenValue,
-	Utility,
-	Variable,
-} from "./types";
-
-export function isObject(value: unknown): value is object {
-	return typeof value === "object" && value !== null;
-}
-
-/**
- * Tokens
- */
-
-export function isToken<T>(value: unknown, type: TokenType): value is T {
-	return isObject(value) && "type" in value && value.type === type;
-}
-
-export function isVariable<Name extends string = string>(
-	value: unknown,
-): value is Variable<Name> {
-	return isToken(value, "variable");
-}
-
-export function isRef<Name extends string = string>(
-	value: unknown,
-): value is Reference<Name> {
-	return isToken(value, "reference");
-}
-
-export function isSelector(value: unknown): value is Selector {
-	return isToken(value, "selector");
-}
-
-export function isAtRule(value: unknown): value is AtRule {
-	return isToken(value, "at-rule");
-}
-
-export function isUtility<Name extends string = string>(
-	value: unknown,
-): value is Utility<Name> {
-	return isToken(value, "utility");
-}
-
-export function isModifier(value: unknown): value is ModifierFactory {
-	return isToken(value, "modifier");
-}
-
-export function isCSS(value: unknown): value is CSS {
-	return isToken(value, "css");
-}
-
-export function isTheme(value: unknown): value is Theme {
-	return isToken(value, "theme");
-}
-
-export function isRoot(value: unknown): value is Root {
-	return isToken(value, "root");
-}
-
-export function isPrimitiveTokenValue(
-	value: unknown,
-): value is PrimitiveTokenValue {
-	return (
-		typeof value === "string" ||
-		typeof value === "number" ||
-		typeof value === "boolean" ||
-		value === null
-	);
-}
-
-export function isTokenValue(value: unknown): value is TokenValue {
-	return (
-		isPrimitiveTokenValue(value) ||
-		isRef(value) ||
-		isCSS(value) ||
-		(Array.isArray(value) && value.every(isTokenValue))
-	);
-}
-
-export function isContainer(value: unknown): value is Container {
-	return (
-		isObject(value) &&
-		"children" in value &&
-		"declarations" in value &&
-		"variables" in value
-	);
-}

package/src/types/declarations.ts

@@ -1,42 +0,0 @@
-import type { Properties as CSSProperties } from "csstype";
-import type {
-	createAtRuleFunction,
-	createCssFunction,
-	createKeyframesFunction,
-	createMediaFunction,
-	createRefFunction,
-	createSelectorFunction,
-	createVariableFunction,
-} from "../tokens";
-import type { TokenValue } from "./tokens";
-
-// Helper type to make CSS property values also accept Reference types
-type CSSValueWithReference<T> = T extends string | number | undefined
-	? T | TokenValue
-	: T extends object
-		? CSSValueWithReference<T>
-		: T | TokenValue;
-
-// Recursively apply the Reference extension to all CSS properties
-export type DeclarationsBlock = {
-	[K in keyof CSSProperties]: CSSValueWithReference<CSSProperties[K]>;
-} & {
-	// Support for nested selectors (like '&:hover', '.child')
-	[key: string]:
-		| CSSValueWithReference<CSSProperties[keyof CSSProperties]>
-		| DeclarationsBlock;
-};
-
-export type DeclarationsCallbackContext = {
-	variable: ReturnType<typeof createVariableFunction>;
-	selector: ReturnType<typeof createSelectorFunction>;
-	atRule: ReturnType<typeof createAtRuleFunction>;
-	keyframes: ReturnType<typeof createKeyframesFunction>;
-	media: ReturnType<typeof createMediaFunction>;
-	ref: ReturnType<typeof createRefFunction>;
-	css: ReturnType<typeof createCssFunction>;
-};
-
-export type DeclarationsCallback<
-	Context extends DeclarationsCallbackContext = DeclarationsCallbackContext,
-> = (context: Context) => DeclarationsBlock | void;

package/src/types/index.ts

@@ -1,3 +0,0 @@
-export * from "./declarations";
-export * from "./options";
-export * from "./tokens";

package/src/types/options.ts

@@ -1,22 +0,0 @@
-export type VariableNameFn = (options: { name: string }) => string;
-
-export type UtilitySelectorFn = (options: {
-	name: string;
-	value: string;
-	modifiers: string[];
-}) => string;
-
-export type ThemeSelectorFn = (options: { name: string }) => string;
-
-export type StyleframeOptions = {
-	indent?: string;
-	variables?: {
-		name?: VariableNameFn;
-	};
-	utilities?: {
-		selector?: UtilitySelectorFn;
-	};
-	theme?: {
-		selector?: ThemeSelectorFn;
-	};
-};