@styleframe/core 1.0.0 → 1.0.2

package/src/tokens/modifier.test.ts

@@ -1,90 +0,0 @@
-import { combineKeys } from "./modifier";
-
-describe("combineKeys", () => {
-	it("returns empty array for empty input", () => {
-		expect(combineKeys([])).toEqual([]);
-	});
-
-	it("handles a single string", () => {
-		expect(combineKeys([["hover"]])).toEqual([["hover"]]);
-	});
-
-	it("combines two strings and sorts combinations by length then alphabetically", () => {
-		const result = combineKeys([["hover"], ["focus"]]);
-		expect(result).toEqual([["focus"], ["hover"], ["focus", "hover"]]);
-	});
-
-	it("combines a string with an array, without combining elements within the array", () => {
-		const result = combineKeys([["hover"], ["sm", "md"]]);
-		expect(result).toEqual([
-			// singles (alphabetical)
-			["hover"],
-			["md"],
-			["sm"],
-			// pairs (alphabetical within and across combinations)
-			["hover", "md"],
-			["hover", "sm"],
-		]);
-	});
-
-	it("combines two arrays, choosing at most one element from each", () => {
-		const result = combineKeys([
-			["sm", "md"],
-			["active", "hover"],
-		]);
-		expect(result).toEqual([
-			// singles (alphabetical)
-			["active"],
-			["hover"],
-			["md"],
-			["sm"],
-			// pairs (cross-product, alphabetical within and across)
-			["active", "md"],
-			["active", "sm"],
-			["hover", "md"],
-			["hover", "sm"],
-		]);
-	});
-
-	it("does not combine elements within the same array when only one array is provided", () => {
-		const result = combineKeys([["a", "b", "c"]]);
-		expect(result).toEqual([["a"], ["b"], ["c"]]);
-	});
-
-	it("generates combinations across three groups and maintains order and uniqueness", () => {
-		const result = combineKeys([["focus"], ["sm", "md"], ["hover", "active"]]);
-
-		// Expect exact ordering: first by length, then alphabetical within each length
-		expect(result).toEqual([
-			// singles
-			["active"],
-			["focus"],
-			["hover"],
-			["md"],
-			["sm"],
-			// pairs
-			["active", "focus"],
-			["active", "md"],
-			["active", "sm"],
-			["focus", "hover"],
-			["focus", "md"],
-			["focus", "sm"],
-			["hover", "md"],
-			["hover", "sm"],
-			// triples
-			["active", "focus", "md"],
-			["active", "focus", "sm"],
-			["focus", "hover", "md"],
-			["focus", "hover", "sm"],
-		]);
-
-		// Assert no duplicates present (defensive check)
-		const unique = new Set(result.map((r) => r.join(",")));
-		expect(unique.size).toBe(result.length);
-	});
-
-	it("sorts elements within each combination alphabetically", () => {
-		const result = combineKeys([["b"], ["a"]]);
-		expect(result).toEqual([["a"], ["b"], ["a", "b"]]);
-	});
-});

package/src/tokens/modifier.ts

@@ -1,86 +0,0 @@
-import type { Container, ModifierFactory, Root } from "../types";
-import { deepClone } from "../utils";
-import {
-	createDeclarationsCallbackContext,
-	parseDeclarationsBlock,
-} from "./declarations";
-
-export function combineKeys(groups: string[][]): string[][] {
-	const result: string[][] = [];
-
-	// Generate all combinations using recursive approach
-	function generateCombinations(groupIndex: number, current: string[]) {
-		// Add current combination if not empty
-		if (current.length > 0) {
-			result.push([...current].sort());
-		}
-
-		// Try adding elements from remaining groups
-		for (let i = groupIndex; i < groups.length; i++) {
-			const group = groups[i];
-
-			if (group) {
-				if (group.length === 1 && !!group[0]) {
-					// Single element (originally a string) - can always add
-					generateCombinations(i + 1, [...current, group[0]]);
-				} else {
-					// Array group - add at most one element
-					for (const element of group) {
-						generateCombinations(i + 1, [...current, element]);
-					}
-				}
-			}
-		}
-	}
-
-	generateCombinations(0, []);
-
-	// Sort result: first by length, then alphabetically
-	return result.sort((a, b) => {
-		if (a.length !== b.length) return a.length - b.length;
-		return a.join(",").localeCompare(b.join(","));
-	});
-}
-
-export function applyModifiers<InstanceType extends Container>(
-	baseInstance: InstanceType,
-	root: Root,
-	modifiers: Map<string, ModifierFactory>,
-): InstanceType {
-	const instance: InstanceType = {
-		...baseInstance,
-		modifiers: [...modifiers.keys()],
-	};
-
-	const callbackContext = createDeclarationsCallbackContext(instance, root);
-
-	for (const modifier of modifiers.values()) {
-		modifier.factory({
-			...callbackContext,
-			declarations: deepClone(instance.declarations),
-			variables: deepClone(instance.variables),
-			children: deepClone(instance.children),
-		});
-
-		parseDeclarationsBlock(instance.declarations, callbackContext);
-	}
-
-	return instance;
-}
-
-export function createModifierFunction(_parent: Container, root: Root) {
-	return function modifier<Key extends string>(
-		key: Key | Key[],
-		factory: ModifierFactory["factory"],
-	): ModifierFactory {
-		const modifierInstance: ModifierFactory = {
-			type: "modifier",
-			key: Array.isArray(key) ? key : [key],
-			factory,
-		};
-
-		root.modifiers.push(modifierInstance);
-
-		return modifierInstance;
-	};
-}

package/src/tokens/recipe.test.ts

@@ -1,105 +0,0 @@
-import { beforeEach, describe, expect, test } from "vitest";
-import type { Root } from "../types";
-import { createRecipeFunction } from "./recipe";
-import { createRoot } from "./root";
-
-describe("createRecipeFunction", () => {
-	let root: Root;
-	let recipe: ReturnType<typeof createRecipeFunction>;
-
-	beforeEach(() => {
-		root = createRoot();
-		recipe = createRecipeFunction(root, root);
-	});
-
-	test("should create a recipe function", () => {
-		expect(recipe).toBeTypeOf("function");
-	});
-
-	test("should register recipe in root.recipes only", () => {
-		const instance = recipe(
-			"button",
-			{ borderWidth: "thin", borderStyle: "solid" },
-			{
-				color: {
-					primary: { background: "primary", color: "white" },
-					secondary: { background: "secondary", color: "white" },
-				},
-				size: {
-					sm: { padding: "sm" },
-					md: { padding: "md" },
-					lg: { padding: "lg" },
-				},
-			},
-		);
-
-		expect(instance).toEqual({
-			type: "recipe",
-			name: "button",
-			defaults: { borderWidth: "thin", borderStyle: "solid" },
-			variants: {
-				color: {
-					primary: { background: "primary", color: "white" },
-					secondary: { background: "secondary", color: "white" },
-				},
-				size: {
-					sm: { padding: "sm" },
-					md: { padding: "md" },
-					lg: { padding: "lg" },
-				},
-			},
-		});
-
-		expect(root.recipes).toHaveLength(1);
-		expect(root.recipes[0]).toBe(instance);
-
-		// Ensure no selectors/variables were created
-		expect(root.children).toHaveLength(0);
-	});
-
-	test("should support options: defaultVariants and compoundVariants", () => {
-		const instance = recipe(
-			"chip",
-			{ borderWidth: "thin" },
-			{
-				variant: {
-					filled: { background: "primary", color: "white" },
-					outline: { background: "transparent", color: "primary" },
-				},
-				size: {
-					sm: { padding: "sm" },
-					md: { padding: "md" },
-				},
-			},
-			{
-				defaultVariants: { variant: "filled", size: "sm" },
-				compoundVariants: [
-					{
-						variant: "filled",
-						size: "sm",
-						declarations: { background: "primary", color: "white" },
-					},
-				],
-			},
-		);
-
-		expect(instance.defaultVariants).toEqual({
-			variant: "filled",
-			size: "sm",
-		});
-		expect(instance.compoundVariants?.length).toBe(1);
-		expect(instance.compoundVariants).toEqual([
-			{
-				variant: "filled",
-				size: "sm",
-				declarations: { background: "primary", color: "white" },
-			},
-		]);
-	});
-
-	test("should maintain type information for recipe name", () => {
-		const instance = recipe("typed-recipe", {}, {});
-		const name: "typed-recipe" = instance.name;
-		expect(name).toBe("typed-recipe");
-	});
-});

package/src/tokens/recipe.ts

@@ -1,32 +0,0 @@
-import type {
-	Container,
-	Recipe,
-	Root,
-	VariantDeclarationsBlock,
-} from "../types";
-
-export function createRecipeFunction(_parent: Container, root: Root) {
-	return function recipe<
-		Name extends string,
-		Variants extends Record<string, Record<string, VariantDeclarationsBlock>>,
-	>(
-		name: Name,
-		defaults: Recipe<Name, Variants>["defaults"],
-		variants: Recipe<Name, Variants>["variants"],
-		options?: {
-			defaultVariants?: Recipe<Name, Variants>["defaultVariants"];
-			compoundVariants?: Recipe<Name, Variants>["compoundVariants"];
-		},
-	): Recipe<Name, Variants> {
-		const instance: Recipe<Name, Variants> = {
-			type: "recipe",
-			name,
-			defaults,
-			variants,
-			...options,
-		};
-
-		root.recipes.push(instance);
-		return instance;
-	};
-}