@lynstack/recipe 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tim Phan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,63 @@
+# @lynstack/recipe
+
+[![npm](https://img.shields.io/npm/v/@lynstack/recipe)](https://www.npmjs.com/package/@lynstack/recipe)
+[![Bundle size](https://img.shields.io/bundlephobia/minzip/@lynstack/recipe)](https://bundlephobia.com/package/@lynstack/recipe)
+[![CI](https://github.com/lynstack/recipe/actions/workflows/ci-recipe.yml/badge.svg)](https://github.com/lynstack/recipe/actions/workflows/ci-recipe.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](LICENSE)
+
+Fast, type-safe recipes for values of any type. Define a kind of recipe by
+how it combines values, such as class names or style objects, then create
+recipes of that kind: functions that map a component's variants to its
+result.
+
+**[Read the documentation](https://lynstack.github.io/recipe/recipe/)**
+
+[`@lynstack/class-recipe`](https://www.npmjs.com/package/@lynstack/class-recipe)
+is built on it. Use `@lynstack/class-recipe` to style components with class
+names; use this package to create recipes for other values.
+
+## Installation
+
+```sh
+npm install @lynstack/recipe
+```
+
+## Usage
+
+```ts
+import { createRecipeKind } from "@lynstack/recipe";
+
+type Style = Readonly<Record<string, string | number>>;
+
+const styleRecipe = createRecipeKind({
+  initial: (base?: Style): Style => ({ ...base }),
+  reduce: (style, value: Style): Style => ({ ...style, ...value }),
+  finish: (style): Style => Object.freeze(style),
+});
+
+const text = styleRecipe({
+  base: { color: "black" },
+  variants: {
+    size: { sm: { fontSize: 12 }, lg: { fontSize: 24 } },
+    muted: { true: { opacity: 0.6 } },
+  },
+  compoundVariants: [
+    { variants: { size: "lg", muted: true }, value: { fontWeight: 300 } },
+  ],
+  defaultVariants: { size: "sm" },
+});
+
+text(); // => { color: "black", fontSize: 12 }
+
+text({ size: "lg", muted: true });
+// => { color: "black", fontSize: 24, opacity: 0.6, fontWeight: 300 }
+```
+
+See [Recipe kinds](https://lynstack.github.io/recipe/recipe/recipe-kinds/)
+for what each function of a kind does, and
+[Practices](https://lynstack.github.io/recipe/recipe/practices/) for how to
+write kinds that stay fast.
+
+## License
+
+[MIT](LICENSE)

package/dist/index.d.ts

@@ -0,0 +1,253 @@
+//#region src/types.d.ts
+/**
+ * Turns a type's intersections into a single object type, so editors show
+ * its properties instead of the types it was built from.
+ */
+type Simplify<Type> = { [Key in keyof Type]: Type[Key]; };
+type OptionName<Options> = `${Extract<keyof Options, string | number>}`;
+type BooleanName = "true" | "false";
+type NumberOption<Options> = Extract<keyof Options, number>;
+type BooleanOption<Name extends string> = [Extract<Name, BooleanName>] extends [never] ? never : BooleanName | boolean;
+type BooleanVariantName<Variants> = { [Name in keyof Variants]: [OptionName<Variants[Name]>] extends [never] ? never : [OptionName<Variants[Name]>] extends [BooleanName] ? Name : never; }[keyof Variants];
+/**
+ * The values accepted for one variant: the names of its options, as
+ * strings or, for numeric names, as numbers, plus `true`, `false`, `"true"`,
+ * and `"false"` when it declares an option named `"true"` or `"false"`.
+ *
+ * @typeParam Options - The options of the variant, keyed by option name.
+ */
+type VariantOption<Options> = OptionName<Options> | NumberOption<Options> | BooleanOption<OptionName<Options>>;
+/**
+ * The variants a selection names. A variant with a default may be omitted,
+ * and so may a boolean variant, whose only options are `"true"` and
+ * `"false"`; any other variant is required.
+ *
+ * @typeParam Variants - The variant definitions, keyed by variant name.
+ * @typeParam DefaultedName - The names of the variants that have a default.
+ */
+type VariantSelection<Variants, DefaultedName extends keyof Variants> = Simplify<{ readonly [Name in Exclude<keyof Variants, DefaultedName | BooleanVariantName<Variants>>]: VariantOption<Variants[Name]>; } & { readonly [Name in DefaultedName | BooleanVariantName<Variants>]?: VariantOption<Variants[Name]> | undefined; }>;
+/**
+ * The option each defaulted variant uses when a selection leaves it out.
+ *
+ * @typeParam Variants - The variant definitions, keyed by variant name.
+ * @typeParam DefaultedName - The names of the variants that have a default.
+ */
+type DefaultVariants<Variants, DefaultedName extends keyof Variants> = { readonly [Name in DefaultedName]: VariantOption<NoInfer<Variants>[Name]>; };
+/**
+ * The condition of a compound variant: for each variant it names, the option
+ * or the list of options that it matches. A variant left out matches any
+ * option.
+ *
+ * @typeParam Variants - The variant definitions, keyed by variant name.
+ */
+type CompoundCondition<Variants> = { readonly [Name in keyof Variants]?: VariantOption<Variants[Name]> | readonly VariantOption<Variants[Name]>[] | undefined; };
+/**
+ * A function that takes the properties of a selection, whose argument is
+ * optional when every property of `Props` is.
+ *
+ * @typeParam Props - The properties the function accepts.
+ * @typeParam Result - What the function returns.
+ */
+type RecipeFunction<Props, Result> = Partial<Props> extends Props ? (props?: Props) => Result : (props: Props) => Result;
+type KeyName<Key> = Key extends string ? Key : Key extends number ? `${Key}` : never;
+/**
+ * The name of each variant in a selection, as a string.
+ *
+ * @typeParam Selection - The variants a selector accepts.
+ */
+type VariantKey<Selection> = KeyName<keyof Selection>;
+//#endregion
+//#region src/variants.d.ts
+/**
+ * Variant definitions in the loose shape the runtime works with: for each
+ * variant name, the value of each of its options.
+ */
+type LooseVariants<Value> = Readonly<Record<string, Readonly<Record<string, Value>>>>;
+//#endregion
+//#region src/recipe-kind.d.ts
+/**
+ * How a kind of recipe turns the values of a selection into its result,
+ * such as by joining class names or merging style objects.
+ *
+ * @typeParam Value - The value of an option.
+ * @typeParam Accumulator - What the values of a selection are reduced to.
+ * @typeParam Result - What a recipe of this kind returns.
+ */
+interface RecipeKind<Value, Accumulator, Result> {
+  /**
+   * Returns the accumulator that the values of a selection are reduced
+   * into, starting from the recipe's `base`, which is `undefined` when the
+   * recipe has none. It is called for each result a recipe builds, so it
+   * can return a new object each time.
+   */
+  readonly initial: (base: Value | undefined) => Accumulator;
+  /**
+   * Adds a value to the accumulator and returns the accumulator. It is
+   * called with the values that apply to a selection, in order of
+   * precedence: the value of each variant's selected option, in the order
+   * of `variants`, then the value of each matching compound variant, in the
+   * order of `compoundVariants`. An option or compound variant whose value
+   * is `undefined` adds nothing.
+   */
+  readonly reduce: (accumulator: Accumulator, value: Value) => Accumulator;
+  /**
+   * Turns the accumulator into the result, for example by freezing it.
+   * Without it, the result is the accumulator.
+   */
+  readonly finish?: ((accumulator: Accumulator) => Result) | undefined;
+  /**
+   * Whether a recipe builds the result of each declared selection once and
+   * returns it again for the same selection. Defaults to `true`.
+   */
+  readonly cache?: boolean | undefined;
+}
+/**
+ * Any selection, for variants whose names are not known at compile time,
+ * such as `Record<string, Record<string, string>>`.
+ */
+type AnySelection = Readonly<Record<string, unknown>>;
+/** The selection of a recipe, or any selection for unknown variant names. */
+type KindSelection<Variants, DefaultedName extends keyof Variants> = string extends keyof Variants ? AnySelection : VariantSelection<Variants, DefaultedName>;
+/** The condition of a compound variant, or any for unknown variant names. */
+type KindCompoundCondition<Variants> = string extends keyof Variants ? AnySelection : CompoundCondition<Variants>;
+/** The default variants of a recipe, or any for unknown variant names. */
+type KindDefaultVariants<Variants, DefaultedName extends keyof Variants> = string extends keyof Variants ? AnySelection : DefaultVariants<Variants, DefaultedName>;
+/**
+ * The variants of a {@link KindRecipeConfig}: for each variant name, the
+ * value of each of its options.
+ *
+ * @typeParam Value - The value of an option.
+ */
+type KindVariants<Value> = LooseVariants<Value>;
+/**
+ * A value added when several variants have particular options at the same
+ * time.
+ *
+ * @typeParam Variants - The variant definitions of the recipe.
+ * @typeParam Value - The value of an option.
+ */
+interface KindCompoundVariant<Variants, Value> {
+  /**
+   * The options that must all be selected for
+   * {@link KindCompoundVariant.value} to apply.
+   */
+  readonly variants: KindCompoundCondition<Variants>;
+  /** The value added when the condition matches. */
+  readonly value: Value;
+}
+/**
+ * The configuration of a recipe made from a {@link RecipeKind}.
+ *
+ * @typeParam Value - The value of an option.
+ * @typeParam Variants - The variant definitions, keyed by variant name.
+ * @typeParam DefaultedName - The names of the variants that have a default.
+ */
+interface KindRecipeConfig<Value, Variants extends KindVariants<Value>, DefaultedName extends keyof Variants> {
+  /** The value that the values of every selection are added to. */
+  readonly base?: Value | undefined;
+  /** For each variant name, the value of each of its options. */
+  readonly variants: Variants;
+  /**
+   * Values added when several variants have particular options at the same
+   * time, applied in order after the values of the variants' options.
+   */
+  readonly compoundVariants?: readonly KindCompoundVariant<NoInfer<Variants>, Value>[] | undefined;
+  /** The option each variant uses when the recipe is called without it. */
+  readonly defaultVariants?: KindDefaultVariants<Variants, DefaultedName> | undefined;
+}
+/**
+ * A recipe made from a {@link RecipeKind}: a function that returns the
+ * result of a selection of variants, with the names of those variants in
+ * `variantKeys`.
+ *
+ * @typeParam Selection - The variants the recipe accepts.
+ * @typeParam Result - What the recipe returns.
+ */
+type KindRecipe<Selection, Result> = RecipeFunction<Selection, Result> & {
+  /**
+   * The names of the recipe's variants, in the order of
+   * `Object.keys(config.variants)`.
+   */
+  readonly variantKeys: readonly VariantKey<Selection>[];
+};
+/**
+ * Creates recipes of one kind, the function that {@link createRecipeKind}
+ * returns.
+ *
+ * @typeParam Value - The value of an option.
+ * @typeParam Result - What a recipe of this kind returns.
+ * @param config - The base value, variants, compound variants, and default
+ *   variants of the recipe.
+ * @returns The recipe.
+ */
+type CreateKindRecipe<Value, Result> = <const Variants extends KindVariants<Value>, const DefaultedName extends keyof Variants = never>(config: KindRecipeConfig<Value, Variants, DefaultedName>) => KindRecipe<KindSelection<Variants, DefaultedName>, Result>;
+/**
+ * Creates a kind of recipe from how it turns the values of a selection into
+ * its result, and returns the function that creates recipes of that kind.
+ * A recipe maps a selection of variants to a result, as `cva` of
+ * `@lynstack/class-recipe` does for class names, for values of any type,
+ * such as style objects.
+ *
+ * @remarks
+ * For each selection, a recipe reduces the value of each variant's selected
+ * option and the value of each matching compound variant, with
+ * `kind.reduce`, into the accumulator that `kind.initial` returns for the
+ * recipe's base, then passes it to `kind.finish`. A variant whose only
+ * options are `"true"` and `"false"` defaults to `false`, an option that the
+ * config does not declare adds no value, and properties of the selection
+ * that are not variants are ignored. A recipe's `variantKeys` property lists
+ * the names of its variants.
+ *
+ * With the cache, a recipe builds the result of each declared selection
+ * once, and calling it again with the same variants returns the same
+ * result. Freeze an object result in `kind.finish` so that callers cannot
+ * change a result that later calls share. A selection with an undeclared
+ * option is built on every call.
+ *
+ * When the variant names are not known at compile time, as in a library
+ * that passes on a config it received, a recipe accepts any selection.
+ *
+ * @typeParam Value - The value of an option, inferred from the `value`
+ *   parameter of `kind.reduce` or the `base` parameter of `kind.initial`.
+ * @typeParam Accumulator - What the values are reduced to, inferred from
+ *   `kind.initial`.
+ * @typeParam Result - What a recipe returns, inferred from `kind.finish`,
+ *   or the accumulator without it.
+ * @param kind - How a recipe turns the values of a selection into its
+ *   result, and whether it caches the result.
+ * @returns The function that creates recipes of this kind.
+ *
+ * @example
+ * ```ts
+ * type Style = Readonly<Record<string, string | number>>;
+ *
+ * const styleRecipe = createRecipeKind({
+ *   initial: (base?: Style): Record<string, string | number> => ({ ...base }),
+ *   reduce: (style, value: Style) => Object.assign(style, value),
+ *   finish: (style): Style => Object.freeze(style),
+ * });
+ *
+ * const text = styleRecipe({
+ *   base: { color: "black" },
+ *   variants: {
+ *     size: { sm: { fontSize: 12 }, lg: { fontSize: 24 } },
+ *     muted: { true: { opacity: 0.6 } },
+ *   },
+ *   compoundVariants: [
+ *     { variants: { size: "lg", muted: true }, value: { fontWeight: 300 } },
+ *   ],
+ *   defaultVariants: { size: "sm" },
+ * });
+ *
+ * text(); // => { color: "black", fontSize: 12 }
+ *
+ * text({ size: "lg", muted: true });
+ * // => { color: "black", fontSize: 24, opacity: 0.6, fontWeight: 300 }
+ *
+ * text.variantKeys; // => ["size", "muted"]
+ * ```
+ */
+declare function createRecipeKind<Value, Accumulator, Result = Accumulator>(kind: RecipeKind<Value, Accumulator, Result>): CreateKindRecipe<Value, Result>;
+//#endregion
+export { type CompoundCondition, type CreateKindRecipe, type DefaultVariants, type KindCompoundVariant, type KindRecipe, type KindRecipeConfig, type KindVariants, type RecipeFunction, type RecipeKind, type VariantOption, type VariantSelection, createRecipeKind };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,153 @@
+const noProps = Object.freeze({});
+/**
+* Prepares variants for selecting values. A variant that declares an option
+* named `"true"` or `"false"` also declares the other one, with
+* `config.noValue`, and a variant whose only options are those defaults to
+* `"false"`. A compound variant that names an undeclared variant or option,
+* or lists no option for a variant, never matches and is left out.
+*/
+function compileVariants(config) {
+	const names = Object.keys(config.variants);
+	const optionValues = names.map((name) => withBooleanOptions(config.variants[name] ?? {}, config.noValue));
+	const indexByOption = optionValues.map((valuesByOption) => new Map(Object.keys(valuesByOption).map((option, index) => [option, index + 1])));
+	const radixes = indexByOption.map((indexes) => indexes.size + 1);
+	return {
+		compounds: compileCompounds(config.compoundVariants, names, indexByOption),
+		defaultOptions: names.map((name, index) => toOptionName(config.defaultVariants[name]) ?? (isBooleanVariant(indexByOption[index]) ? "false" : void 0)),
+		indexByOption,
+		isCacheable: product(radixes) <= Number.MAX_SAFE_INTEGER,
+		names,
+		strides: radixes.map((_radix, index) => product(radixes.slice(0, index))),
+		valuesByIndex: valuesByIndexOf(optionValues, config.noValue)
+	};
+}
+/**
+* Writes the option index of each variant for `selected` into `indexes`
+* and returns the selection's key, or {@link undeclared} when an option is
+* not declared.
+*/
+function select(compiled, selected, indexes) {
+	let key = 0;
+	for (let variant = 0; variant < compiled.names.length; variant += 1) {
+		const index = selectIndex(compiled, selected, variant);
+		indexes[variant] = index ?? 0;
+		key = index === void 0 || key === -1 ? -1 : key + index * (compiled.strides[variant] ?? 0);
+	}
+	return key;
+}
+function selectIndex(compiled, selected, variant) {
+	const option = toOptionName(selected[compiled.names[variant] ?? ""]) ?? compiled.defaultOptions[variant];
+	return option === void 0 ? 0 : compiled.indexByOption[variant]?.get(option);
+}
+function valuesByIndexOf(optionValues, noValue) {
+	const valuesByIndex = [];
+	for (const valuesByOption of optionValues) valuesByIndex.push([noValue, ...Object.values(valuesByOption)]);
+	return valuesByIndex;
+}
+function product(numbers) {
+	return numbers.reduce((result, number) => result * number, 1);
+}
+function withBooleanOptions(valuesByOption, noValue) {
+	if (!Object.keys(valuesByOption).some((option) => isBooleanName(option))) return valuesByOption;
+	return {
+		false: noValue,
+		true: noValue,
+		...valuesByOption
+	};
+}
+function compileCompounds(compoundVariants, names, indexByOption) {
+	return compoundVariants.flatMap(({ variants, value }) => {
+		const conditions = Object.keys(variants).filter((name) => variants[name] !== void 0).map((name) => compileCondition(indexByOption, names.indexOf(name), variants[name]));
+		return conditions.every(([, indexes]) => indexes.length > 0) ? [{
+			conditions,
+			value
+		}] : [];
+	});
+}
+function compileCondition(indexByOption, variant, value) {
+	const indexes = indexByOption[variant];
+	return [variant, toOptionNames(value).map((option) => indexes?.get(option)).filter((index) => index !== void 0)];
+}
+function isBooleanVariant(indexByOption) {
+	return indexByOption !== void 0 && indexByOption.size > 0 && [...indexByOption.keys()].every((option) => isBooleanName(option));
+}
+function toOptionName(value) {
+	if (typeof value === "string") return value;
+	return typeof value === "number" || typeof value === "boolean" ? String(value) : void 0;
+}
+function toOptionNames(value) {
+	return (Array.isArray(value) ? value : [value]).map((option) => toOptionName(option)).filter((option) => option !== void 0);
+}
+/** Adds the names of the compiled variants to `recipe` as `variantKeys`. */
+function withVariantKeys(recipe, compiled) {
+	return Object.assign(recipe, { variantKeys: Object.freeze([...compiled.names]) });
+}
+function isBooleanName(option) {
+	return option === "true" || option === "false";
+}
+//#endregion
+//#region src/selector.ts
+/**
+* Returns a function that builds the result of a selection from the option
+* index of each variant, and treats a missing selection as an empty one.
+* With `options.cache`, it builds the result of each declared selection
+* once and caches it by the selection's key.
+*/
+function createSelector(compiled, build, options) {
+	const indexes = new Int32Array(compiled.names.length);
+	const results = options.cache && compiled.isCacheable ? /* @__PURE__ */ new Map() : void 0;
+	return (selected) => {
+		const key = select(compiled, selected ?? noProps, indexes);
+		const cachedResult = key === -1 ? void 0 : results?.get(key);
+		if (cachedResult !== void 0) return cachedResult;
+		const result = build(indexes);
+		if (key !== -1) results?.set(key, result);
+		return result;
+	};
+}
+//#endregion
+//#region src/reduce-values.ts
+/** Whether every condition of `compound` matches the selected indexes. */
+function matches(compound, indexes) {
+	for (const [variant, matchingIndexes] of compound.conditions) if (!matchingIndexes.includes(indexes[variant] ?? 0)) return false;
+	return true;
+}
+/**
+* Reduces the values that apply to a selection, in order of precedence: the
+* value of each variant's option, then the value of each matching compound
+* variant. A value that is undefined adds nothing.
+*/
+function reduceValues(compiled, indexes, reducer) {
+	const { reduce } = reducer;
+	let accumulator = reducer.initial();
+	for (let variant = 0; variant < compiled.valuesByIndex.length; variant += 1) {
+		const value = compiled.valuesByIndex[variant]?.[indexes[variant] ?? 0];
+		if (value !== void 0) accumulator = reduce(accumulator, value);
+	}
+	for (const compound of compiled.compounds) if (compound.value !== void 0 && matches(compound, indexes)) accumulator = reduce(accumulator, compound.value);
+	return accumulator;
+}
+//#endregion
+//#region src/recipe-kind.ts
+function createRecipeKind(kind) {
+	const { initial, reduce, finish } = kind;
+	const options = { cache: kind.cache ?? true };
+	return (config) => {
+		const { base } = config;
+		const compiled = compileVariants({
+			compoundVariants: config.compoundVariants ?? [],
+			defaultVariants: config.defaultVariants ?? {},
+			noValue: void 0,
+			variants: config.variants
+		});
+		const reducer = {
+			initial: () => initial(base),
+			reduce
+		};
+		return withVariantKeys(createSelector(compiled, finish === void 0 ? (indexes) => reduceValues(compiled, indexes, reducer) : (indexes) => finish(reduceValues(compiled, indexes, reducer)), options), compiled);
+	};
+}
+//#endregion
+export { createRecipeKind };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/variants.ts","../src/selector.ts","../src/reduce-values.ts","../src/recipe-kind.ts"],"sourcesContent":["/**\n * Variant definitions in the loose shape the runtime works with: for each\n * variant name, the value of each of its options.\n */\ntype LooseVariants<Value> = Readonly<\n  Record<string, Readonly<Record<string, Value>>>\n>;\n\n/** A selection in the loose shape the runtime works with. */\ntype SelectedVariants = Readonly<Record<string, unknown>>;\n\n/** A compound variant in the loose shape the runtime works with. */\ninterface LooseCompoundVariant<Value> {\n  readonly variants: SelectedVariants;\n  readonly value: Value;\n}\n\n/** The variant's index and the option indexes that a condition matches. */\ntype CompoundCondition = readonly [number, readonly number[]];\n\n/** A compound variant prepared for matching. */\ninterface Compound<Value> {\n  readonly conditions: readonly CompoundCondition[];\n  readonly value: Value;\n}\n\n/** What {@link compileVariants} prepares. */\ninterface VariantsConfig<Value> {\n  readonly variants: LooseVariants<Value>;\n  readonly defaultVariants: SelectedVariants;\n  readonly compoundVariants: readonly LooseCompoundVariant<Value>[];\n  /**\n   * The value of a variant without a selected option, and of a boolean\n   * option that the variant does not declare.\n   */\n  readonly noValue: Value;\n}\n\n/**\n * Variants prepared for selecting values. Each variant numbers its options\n * from 1, and 0 stands for no option, so a selection is a list of option\n * indexes. Read together as the digits of a mixed-radix number, they form\n * the selection's key.\n */\ninterface CompiledVariants<Value> {\n  readonly names: readonly string[];\n  readonly defaultOptions: readonly (string | undefined)[];\n  readonly indexByOption: readonly ReadonlyMap<string, number>[];\n  /** The value of each variant's options, by option index. */\n  readonly valuesByIndex: readonly (readonly Value[])[];\n  readonly strides: readonly number[];\n  readonly compounds: readonly Compound<Value>[];\n  /** Whether every selection's key is a safe integer. */\n  readonly isCacheable: boolean;\n}\n\n/** The option index of a variant without a selected option. */\nconst noOption = 0;\n\n/** The key of a selection with an option that a variant does not declare. */\nconst undeclared = -1;\n\nconst noProps: SelectedVariants = Object.freeze({});\n\n/**\n * Prepares variants for selecting values. A variant that declares an option\n * named `\"true\"` or `\"false\"` also declares the other one, with\n * `config.noValue`, and a variant whose only options are those defaults to\n * `\"false\"`. A compound variant that names an undeclared variant or option,\n * or lists no option for a variant, never matches and is left out.\n */\nfunction compileVariants<Value>(\n  config: VariantsConfig<Value>,\n): CompiledVariants<Value> {\n  const names = Object.keys(config.variants);\n  const optionValues = names.map((name) =>\n    withBooleanOptions(config.variants[name] ?? {}, config.noValue),\n  );\n  const indexByOption: readonly ReadonlyMap<string, number>[] =\n    optionValues.map(\n      (valuesByOption) =>\n        new Map(\n          Object.keys(valuesByOption).map((option, index) => [\n            option,\n            index + 1,\n          ]),\n        ),\n    );\n  const radixes = indexByOption.map((indexes) => indexes.size + 1);\n\n  return {\n    compounds: compileCompounds(config.compoundVariants, names, indexByOption),\n    defaultOptions: names.map(\n      (name, index) =>\n        toOptionName(config.defaultVariants[name]) ??\n        (isBooleanVariant(indexByOption[index]) ? \"false\" : undefined),\n    ),\n    indexByOption,\n    isCacheable: product(radixes) <= Number.MAX_SAFE_INTEGER,\n    names,\n    strides: radixes.map((_radix, index) => product(radixes.slice(0, index))),\n    valuesByIndex: valuesByIndexOf(optionValues, config.noValue),\n  };\n}\n\n/**\n * Writes the option index of each variant for `selected` into `indexes`\n * and returns the selection's key, or {@link undeclared} when an option is\n * not declared.\n */\nfunction select(\n  compiled: CompiledVariants<unknown>,\n  selected: SelectedVariants,\n  indexes: Int32Array,\n): number {\n  let key = 0;\n  for (let variant = 0; variant < compiled.names.length; variant += 1) {\n    const index = selectIndex(compiled, selected, variant);\n    indexes[variant] = index ?? noOption;\n    key =\n      index === undefined || key === undeclared\n        ? undeclared\n        : key + index * (compiled.strides[variant] ?? 0);\n  }\n  return key;\n}\n\nfunction selectIndex(\n  compiled: CompiledVariants<unknown>,\n  selected: SelectedVariants,\n  variant: number,\n): number | undefined {\n  const option =\n    toOptionName(selected[compiled.names[variant] ?? \"\"]) ??\n    compiled.defaultOptions[variant];\n  return option === undefined\n    ? noOption\n    : compiled.indexByOption[variant]?.get(option);\n}\n\nfunction valuesByIndexOf<Value>(\n  optionValues: readonly Readonly<Record<string, Value>>[],\n  noValue: Value,\n): Value[][] {\n  const valuesByIndex: Value[][] = [];\n  for (const valuesByOption of optionValues) {\n    valuesByIndex.push([noValue, ...Object.values(valuesByOption)]);\n  }\n  return valuesByIndex;\n}\n\nfunction product(numbers: readonly number[]): number {\n  return numbers.reduce((result, number) => result * number, 1);\n}\n\nfunction withBooleanOptions<Value>(\n  valuesByOption: Readonly<Record<string, Value>>,\n  noValue: Value,\n): Readonly<Record<string, Value>> {\n  const optionNames = Object.keys(valuesByOption);\n  if (!optionNames.some((option) => isBooleanName(option))) {\n    return valuesByOption;\n  }\n  return { false: noValue, true: noValue, ...valuesByOption };\n}\n\nfunction compileCompounds<Value>(\n  compoundVariants: readonly LooseCompoundVariant<Value>[],\n  names: readonly string[],\n  indexByOption: readonly ReadonlyMap<string, number>[],\n): Compound<Value>[] {\n  return compoundVariants.flatMap(({ variants, value }) => {\n    const conditions = Object.keys(variants)\n      .filter((name) => variants[name] !== undefined)\n      .map((name) =>\n        compileCondition(indexByOption, names.indexOf(name), variants[name]),\n      );\n    return conditions.every(([, indexes]) => indexes.length > 0)\n      ? [{ conditions, value }]\n      : [];\n  });\n}\n\nfunction compileCondition(\n  indexByOption: readonly ReadonlyMap<string, number>[],\n  variant: number,\n  value: unknown,\n): CompoundCondition {\n  const indexes = indexByOption[variant];\n  return [\n    variant,\n    toOptionNames(value)\n      .map((option) => indexes?.get(option))\n      .filter((index) => index !== undefined),\n  ];\n}\n\nfunction isBooleanVariant(\n  indexByOption: ReadonlyMap<string, number> | undefined,\n): boolean {\n  return (\n    indexByOption !== undefined &&\n    indexByOption.size > 0 &&\n    [...indexByOption.keys()].every((option) => isBooleanName(option))\n  );\n}\n\nfunction toOptionName(value: unknown): string | undefined {\n  if (typeof value === \"string\") {\n    return value;\n  }\n  return typeof value === \"number\" || typeof value === \"boolean\"\n    ? String(value)\n    : undefined;\n}\n\nfunction toOptionNames(value: unknown): readonly string[] {\n  const values: readonly unknown[] = Array.isArray(value) ? value : [value];\n  return values\n    .map((option) => toOptionName(option))\n    .filter((option) => option !== undefined);\n}\n\n/** A recipe function with the names of its variants. */\ntype WithVariantKeys<Recipe> = Recipe & {\n  readonly variantKeys: readonly string[];\n};\n\n/** Adds the names of the compiled variants to `recipe` as `variantKeys`. */\nfunction withVariantKeys<Recipe extends object>(\n  recipe: Recipe,\n  compiled: CompiledVariants<unknown>,\n): WithVariantKeys<Recipe> {\n  return Object.assign(recipe, {\n    variantKeys: Object.freeze([...compiled.names]),\n  });\n}\n\nfunction isBooleanName(option: string): boolean {\n  return option === \"true\" || option === \"false\";\n}\n\nexport {\n  compileVariants,\n  noOption,\n  noProps,\n  select,\n  undeclared,\n  withVariantKeys,\n};\nexport type {\n  CompiledVariants,\n  Compound,\n  LooseCompoundVariant,\n  LooseVariants,\n  SelectedVariants,\n  WithVariantKeys,\n};\n","import type { CompiledVariants, SelectedVariants } from \"./variants.js\";\nimport { noProps, select, undeclared } from \"./variants.js\";\n\n/** How a selector computes its results. */\ninterface SelectorOptions {\n  /** Whether to cache the result of each declared selection. */\n  readonly cache: boolean;\n}\n\n/**\n * Returns a function that builds the result of a selection from the option\n * index of each variant, and treats a missing selection as an empty one.\n * With `options.cache`, it builds the result of each declared selection\n * once and caches it by the selection's key.\n */\nfunction createSelector<Result>(\n  compiled: CompiledVariants<unknown>,\n  build: (indexes: Int32Array) => Result,\n  options: SelectorOptions,\n): (selected?: SelectedVariants | null) => Result {\n  const indexes = new Int32Array(compiled.names.length);\n  const results =\n    options.cache && compiled.isCacheable\n      ? new Map<number, Result>()\n      : undefined;\n\n  return (selected) => {\n    const key = select(compiled, selected ?? noProps, indexes);\n    const cachedResult = key === undeclared ? undefined : results?.get(key);\n    if (cachedResult !== undefined) {\n      return cachedResult;\n    }\n    const result = build(indexes);\n    if (key !== undeclared) {\n      results?.set(key, result);\n    }\n    return result;\n  };\n}\n\nexport { createSelector };\nexport type { SelectorOptions };\n","import type { CompiledVariants, Compound } from \"./variants.js\";\nimport { noOption } from \"./variants.js\";\n\n/** Whether every condition of `compound` matches the selected indexes. */\nfunction matches(compound: Compound<unknown>, indexes: Int32Array): boolean {\n  for (const [variant, matchingIndexes] of compound.conditions) {\n    if (!matchingIndexes.includes(indexes[variant] ?? noOption)) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/** Reduces the values of a selection to an accumulator. */\ninterface Reducer<Value, Accumulator> {\n  /** Returns the accumulator to start from. */\n  readonly initial: () => Accumulator;\n  /** Adds a value to the accumulator and returns the accumulator. */\n  readonly reduce: (accumulator: Accumulator, value: Value) => Accumulator;\n}\n\n/**\n * Reduces the values that apply to a selection, in order of precedence: the\n * value of each variant's option, then the value of each matching compound\n * variant. A value that is undefined adds nothing.\n */\nfunction reduceValues<Value, Accumulator>(\n  compiled: CompiledVariants<Value | undefined>,\n  indexes: Int32Array,\n  reducer: Reducer<Value, Accumulator>,\n): Accumulator {\n  const { reduce } = reducer;\n  let accumulator = reducer.initial();\n  for (let variant = 0; variant < compiled.valuesByIndex.length; variant += 1) {\n    const value =\n      compiled.valuesByIndex[variant]?.[indexes[variant] ?? noOption];\n    if (value !== undefined) {\n      accumulator = reduce(accumulator, value);\n    }\n  }\n  for (const compound of compiled.compounds) {\n    if (compound.value !== undefined && matches(compound, indexes)) {\n      accumulator = reduce(accumulator, compound.value);\n    }\n  }\n  return accumulator;\n}\n\nexport { reduceValues };\nexport type { Reducer };\n","import type {\n  CompoundCondition,\n  DefaultVariants,\n  RecipeFunction,\n  VariantKey,\n  VariantSelection,\n} from \"./types.js\";\nimport type {\n  LooseVariants,\n  SelectedVariants,\n  WithVariantKeys,\n} from \"./variants.js\";\nimport { compileVariants, withVariantKeys } from \"./variants.js\";\nimport { createSelector } from \"./selector.js\";\nimport { reduceValues } from \"./reduce-values.js\";\n\n/**\n * How a kind of recipe turns the values of a selection into its result,\n * such as by joining class names or merging style objects.\n *\n * @typeParam Value - The value of an option.\n * @typeParam Accumulator - What the values of a selection are reduced to.\n * @typeParam Result - What a recipe of this kind returns.\n */\ninterface RecipeKind<Value, Accumulator, Result> {\n  /**\n   * Returns the accumulator that the values of a selection are reduced\n   * into, starting from the recipe's `base`, which is `undefined` when the\n   * recipe has none. It is called for each result a recipe builds, so it\n   * can return a new object each time.\n   */\n  readonly initial: (base: Value | undefined) => Accumulator;\n  /**\n   * Adds a value to the accumulator and returns the accumulator. It is\n   * called with the values that apply to a selection, in order of\n   * precedence: the value of each variant's selected option, in the order\n   * of `variants`, then the value of each matching compound variant, in the\n   * order of `compoundVariants`. An option or compound variant whose value\n   * is `undefined` adds nothing.\n   */\n  readonly reduce: (accumulator: Accumulator, value: Value) => Accumulator;\n  /**\n   * Turns the accumulator into the result, for example by freezing it.\n   * Without it, the result is the accumulator.\n   */\n  readonly finish?: ((accumulator: Accumulator) => Result) | undefined;\n  /**\n   * Whether a recipe builds the result of each declared selection once and\n   * returns it again for the same selection. Defaults to `true`.\n   */\n  readonly cache?: boolean | undefined;\n}\n\n/**\n * Any selection, for variants whose names are not known at compile time,\n * such as `Record<string, Record<string, string>>`.\n */\ntype AnySelection = Readonly<Record<string, unknown>>;\n\n/** The selection of a recipe, or any selection for unknown variant names. */\ntype KindSelection<\n  Variants,\n  DefaultedName extends keyof Variants,\n> = string extends keyof Variants\n  ? AnySelection\n  : VariantSelection<Variants, DefaultedName>;\n\n/** The condition of a compound variant, or any for unknown variant names. */\ntype KindCompoundCondition<Variants> = string extends keyof Variants\n  ? AnySelection\n  : CompoundCondition<Variants>;\n\n/** The default variants of a recipe, or any for unknown variant names. */\ntype KindDefaultVariants<\n  Variants,\n  DefaultedName extends keyof Variants,\n> = string extends keyof Variants\n  ? AnySelection\n  : DefaultVariants<Variants, DefaultedName>;\n\n/**\n * The variants of a {@link KindRecipeConfig}: for each variant name, the\n * value of each of its options.\n *\n * @typeParam Value - The value of an option.\n */\ntype KindVariants<Value> = LooseVariants<Value>;\n\n/**\n * A value added when several variants have particular options at the same\n * time.\n *\n * @typeParam Variants - The variant definitions of the recipe.\n * @typeParam Value - The value of an option.\n */\ninterface KindCompoundVariant<Variants, Value> {\n  /**\n   * The options that must all be selected for\n   * {@link KindCompoundVariant.value} to apply.\n   */\n  readonly variants: KindCompoundCondition<Variants>;\n  /** The value added when the condition matches. */\n  readonly value: Value;\n}\n\n/**\n * The configuration of a recipe made from a {@link RecipeKind}.\n *\n * @typeParam Value - The value of an option.\n * @typeParam Variants - The variant definitions, keyed by variant name.\n * @typeParam DefaultedName - The names of the variants that have a default.\n */\ninterface KindRecipeConfig<\n  Value,\n  Variants extends KindVariants<Value>,\n  DefaultedName extends keyof Variants,\n> {\n  /** The value that the values of every selection are added to. */\n  readonly base?: Value | undefined;\n  /** For each variant name, the value of each of its options. */\n  readonly variants: Variants;\n  /**\n   * Values added when several variants have particular options at the same\n   * time, applied in order after the values of the variants' options.\n   */\n  readonly compoundVariants?:\n    readonly KindCompoundVariant<NoInfer<Variants>, Value>[] | undefined;\n  /** The option each variant uses when the recipe is called without it. */\n  readonly defaultVariants?:\n    KindDefaultVariants<Variants, DefaultedName> | undefined;\n}\n\n/**\n * A recipe made from a {@link RecipeKind}: a function that returns the\n * result of a selection of variants, with the names of those variants in\n * `variantKeys`.\n *\n * @typeParam Selection - The variants the recipe accepts.\n * @typeParam Result - What the recipe returns.\n */\ntype KindRecipe<Selection, Result> = RecipeFunction<Selection, Result> & {\n  /**\n   * The names of the recipe's variants, in the order of\n   * `Object.keys(config.variants)`.\n   */\n  readonly variantKeys: readonly VariantKey<Selection>[];\n};\n\n/**\n * Creates recipes of one kind, the function that {@link createRecipeKind}\n * returns.\n *\n * @typeParam Value - The value of an option.\n * @typeParam Result - What a recipe of this kind returns.\n * @param config - The base value, variants, compound variants, and default\n *   variants of the recipe.\n * @returns The recipe.\n */\ntype CreateKindRecipe<Value, Result> = <\n  const Variants extends KindVariants<Value>,\n  const DefaultedName extends keyof Variants = never,\n>(\n  config: KindRecipeConfig<Value, Variants, DefaultedName>,\n) => KindRecipe<KindSelection<Variants, DefaultedName>, Result>;\n\ninterface LooseRecipeKind {\n  readonly initial: (base: unknown) => unknown;\n  readonly reduce: (accumulator: unknown, value: unknown) => unknown;\n  readonly finish?: ((accumulator: unknown) => unknown) | undefined;\n  readonly cache?: boolean | undefined;\n}\n\ninterface LooseKindRecipeConfig {\n  readonly base?: unknown;\n  readonly variants: KindVariants<unknown>;\n  readonly compoundVariants?:\n    | readonly {\n        readonly variants: SelectedVariants;\n        readonly value: unknown;\n      }[]\n    | undefined;\n  readonly defaultVariants?: SelectedVariants | undefined;\n}\n\ntype LooseKindRecipe = WithVariantKeys<\n  (selection?: SelectedVariants | null) => unknown\n>;\n\n/**\n * Creates a kind of recipe from how it turns the values of a selection into\n * its result, and returns the function that creates recipes of that kind.\n * A recipe maps a selection of variants to a result, as `cva` of\n * `@lynstack/class-recipe` does for class names, for values of any type,\n * such as style objects.\n *\n * @remarks\n * For each selection, a recipe reduces the value of each variant's selected\n * option and the value of each matching compound variant, with\n * `kind.reduce`, into the accumulator that `kind.initial` returns for the\n * recipe's base, then passes it to `kind.finish`. A variant whose only\n * options are `\"true\"` and `\"false\"` defaults to `false`, an option that the\n * config does not declare adds no value, and properties of the selection\n * that are not variants are ignored. A recipe's `variantKeys` property lists\n * the names of its variants.\n *\n * With the cache, a recipe builds the result of each declared selection\n * once, and calling it again with the same variants returns the same\n * result. Freeze an object result in `kind.finish` so that callers cannot\n * change a result that later calls share. A selection with an undeclared\n * option is built on every call.\n *\n * When the variant names are not known at compile time, as in a library\n * that passes on a config it received, a recipe accepts any selection.\n *\n * @typeParam Value - The value of an option, inferred from the `value`\n *   parameter of `kind.reduce` or the `base` parameter of `kind.initial`.\n * @typeParam Accumulator - What the values are reduced to, inferred from\n *   `kind.initial`.\n * @typeParam Result - What a recipe returns, inferred from `kind.finish`,\n *   or the accumulator without it.\n * @param kind - How a recipe turns the values of a selection into its\n *   result, and whether it caches the result.\n * @returns The function that creates recipes of this kind.\n *\n * @example\n * ```ts\n * type Style = Readonly<Record<string, string | number>>;\n *\n * const styleRecipe = createRecipeKind({\n *   initial: (base?: Style): Record<string, string | number> => ({ ...base }),\n *   reduce: (style, value: Style) => Object.assign(style, value),\n *   finish: (style): Style => Object.freeze(style),\n * });\n *\n * const text = styleRecipe({\n *   base: { color: \"black\" },\n *   variants: {\n *     size: { sm: { fontSize: 12 }, lg: { fontSize: 24 } },\n *     muted: { true: { opacity: 0.6 } },\n *   },\n *   compoundVariants: [\n *     { variants: { size: \"lg\", muted: true }, value: { fontWeight: 300 } },\n *   ],\n *   defaultVariants: { size: \"sm\" },\n * });\n *\n * text(); // => { color: \"black\", fontSize: 12 }\n *\n * text({ size: \"lg\", muted: true });\n * // => { color: \"black\", fontSize: 24, opacity: 0.6, fontWeight: 300 }\n *\n * text.variantKeys; // => [\"size\", \"muted\"]\n * ```\n */\nfunction createRecipeKind<Value, Accumulator, Result = Accumulator>(\n  kind: RecipeKind<Value, Accumulator, Result>,\n): CreateKindRecipe<Value, Result>;\n\nfunction createRecipeKind(kind: LooseRecipeKind): unknown {\n  const { initial, reduce, finish } = kind;\n  const options = { cache: kind.cache ?? true };\n\n  return (config: LooseKindRecipeConfig): LooseKindRecipe => {\n    const { base } = config;\n    const compiled = compileVariants<unknown>({\n      compoundVariants: config.compoundVariants ?? [],\n      defaultVariants: config.defaultVariants ?? {},\n      noValue: undefined,\n      variants: config.variants,\n    });\n    const reducer = { initial: (): unknown => initial(base), reduce };\n    const build =\n      finish === undefined\n        ? (indexes: Int32Array): unknown =>\n            reduceValues(compiled, indexes, reducer)\n        : (indexes: Int32Array): unknown =>\n            finish(reduceValues(compiled, indexes, reducer));\n    return withVariantKeys(createSelector(compiled, build, options), compiled);\n  };\n}\n\nexport { createRecipeKind };\nexport type {\n  CreateKindRecipe,\n  KindCompoundVariant,\n  KindRecipe,\n  KindRecipeConfig,\n  KindVariants,\n  RecipeKind,\n};\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@lynstack/recipe",
+  "version": "1.0.0",
+  "description": "Fast, type-safe recipes for values of any type: define how a kind of recipe combines values, such as class names or styles, then create recipes of that kind.",
+  "keywords": [
+    "recipe",
+    "styles",
+    "variants"
+  ],
+  "homepage": "https://lynstack.github.io/recipe/recipe/",
+  "bugs": "https://github.com/lynstack/recipe/issues",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lynstack/recipe.git",
+    "directory": "packages/recipe"
+  },
+  "license": "MIT",
+  "author": "Tim Phan",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc -p tsconfig.json && tsc -p tsconfig.build.json --noEmit",
+    "lint": "oxlint",
+    "format:check": "prettier --check . --ignore-path ../../.gitignore --ignore-path ../../.prettierignore",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "test:consumer": "tsc -p fixtures/consumer/tsconfig.json",
+    "bench": "pnpm build && vitest bench --run",
+    "check": "pnpm build && pnpm typecheck && pnpm test:consumer && pnpm lint && pnpm format:check && pnpm test",
+    "prepack": "pnpm build"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}