@yahoo/uds-v5-wip 1.60.0 → 1.62.0

package/dist/config/dist/defineStyleProp.d.ts

@@ -1,93 +0,0 @@
-import { CssValueTypeName } from "./types/css-values.js";
-
-//#region ../config/dist/defineStyleProp.d.ts
-/** Runtime input type for `toCss` based on the entry's `type`. */
-type ArbitraryRuntimeValue<T extends CssValueTypeName> = T extends 'integer' | 'number' ? number : string;
-/**
- * One entry in a multi-shape `arbitrary` array. The first entry whose `type`
- * (or `pattern`, for `'regex'`) matches the runtime value wins.
- */
-type ArbitraryEntry = { [T in CssValueTypeName]: {
-  type: T;
-  toCss?: (value: ArbitraryRuntimeValue<T>) => string;
-} }[CssValueTypeName] | {
-  type: 'regex';
-  pattern: RegExp;
-  toCss?: (value: string) => string;
-};
-/**
- * Shape of the `arbitrary` field on a style prop:
- *  - A bare value-type name (`'length-percentage'`, `'color'`, etc.) for the
- *    single-shape case.
- *  - An array of {@link ArbitraryEntry} for multi-shape acceptance.
- */
-type ArbitrarySpec = CssValueTypeName | readonly ArbitraryEntry[];
-/**
- * The literal-keyword subset of values a property accepts, derived from
- * {@link CssPropertyValues}[P]. For custom CSS properties (`--*`) the value
- * type is governed by the required `cssType` field instead, so any string
- * is accepted at the type level.
- */
-type StylePropMetadata = {
-  label?: string;
-  description?: string;
-};
-/**
- * A finalized style prop. Returned by `defineStyleProp(spec)` (or the
- * `.metadata({...})` chain). Consumers wrap these in
- * `uds.registerStyleProps({ <propName>: ... })`.
- *
- * `cssProperty` is passed through verbatim from the authored input:
- *  - **string** — a direct prop writing one CSS property.
- *  - **`readonly string[]`** — a fan-out prop writing every CSS
- *    property in the list (e.g. `borderRadiusStart` covering both
- *    start-side corners).
- *
- * Readers that need iteration normalize at the call site
- * (`Array.isArray(p) ? p : [p]`); readers that only need the primary
- * use the string directly or `Array.isArray(p) ? p[0] : p`.
- */
-/**
- * Internal shape attached to a {@link StyleProp} by `.withOpacity()`.
- * The resolver inspects this at `resolveConfig` time to synthesize a
- * second {@link ResolvedStyleProp} for the opacity sibling.
- */
-interface OpacityPairSpec {
-  /** JSX-prop name for the opacity sibling, e.g. `'bgOpacity'`. */
-  readonly as: string;
-  /** Token-group refs the opacity sibling accepts as values. */
-  readonly values: readonly unknown[];
-  /**
-   * Separator between the parent's value-token suffix and the opacity
-   * value in the emitted class name (`bg-primary_75` vs.
-   * `bg-primary/75`). Defaults to `_`.
-   */
-  readonly separator: string;
-}
-/**
- * Structurally-loose form of {@link StyleProp}. Any concrete `StyleProp<P>`
- * is assignable to this. Used at registration / resolution boundaries where
- * the generic `P` would otherwise cause TS2590 by re-expanding
- * `ValuesEntry<P>` across the full property union.
- */
-interface AnyStyleProp {
-  readonly kind: 'styleProp';
-  readonly cssProperty: string | readonly string[];
-  readonly classPrefix: string;
-  readonly values: readonly unknown[];
-  readonly arbitrary?: ArbitrarySpec;
-  readonly cssType?: CssValueTypeName;
-  readonly metadata: StylePropMetadata;
-  readonly opacityPair?: OpacityPairSpec;
-}
-/**
- * Return shape of {@link defineStyleProp}. The `metadata` field doubles as
- * a callable chain: read it to access `{ label?, description? }` (both
- * optional, so an unset metadata reads `undefined` for either field) or
- * call it as `.metadata({ label, description })` to attach metadata and
- * get back a plain {@link StyleProp}. A function satisfies the
- * {@link StylePropMetadata} structural shape because both fields are
- * optional, so the dual nature is type-safe.
- */
-//#endregion
-export { AnyStyleProp, ArbitraryEntry, ArbitrarySpec, StylePropMetadata };

package/dist/config/dist/defineStyleProp.js

@@ -1,60 +0,0 @@
-//#region ../config/dist/defineStyleProp.js
-const CUSTOM_PROPERTY_PREFIX = "--";
-/**
-* Author a style prop. Returns a {@link StyleProp} directly so callers can
-* skip the `.metadata({...})` chain when there's nothing to attach:
-*
-* ```ts
-* defineStyleProp({ cssProperty: 'flex-direction', classPrefix: 'flex', values: ['row', 'col'] })
-* ```
-*
-* The returned object still supports `.metadata({...})` for the common
-* case where you want to attach a label/description — the chain returns a
-* plain {@link StyleProp} with the metadata baked in. Pure — no global
-* registration.
-*/
-function defineStyleProp(spec) {
-	const { cssProperty: cssPropertyInput, classPrefix, values, arbitrary, cssType } = spec;
-	let cssProperty;
-	if (Array.isArray(cssPropertyInput)) {
-		const deduped = Array.from(new Set(cssPropertyInput));
-		if (deduped.length === 0) throw new Error("defineStyleProp: `cssProperty` array must contain at least one CSS property.");
-		cssProperty = deduped;
-	} else cssProperty = cssPropertyInput;
-	const allProperties = Array.isArray(cssProperty) ? cssProperty : [cssProperty];
-	const hasCustom = allProperties.some((p) => p.startsWith(CUSTOM_PROPERTY_PREFIX));
-	if (allProperties.length > 1 && hasCustom) throw new Error(`defineStyleProp: \`cssProperty\` arrays must be standard CSS properties only; custom (\`--*\`) properties must use the single-string form. Got ${JSON.stringify(cssProperty)}.`);
-	const isCustomProperty = hasCustom;
-	if (isCustomProperty && cssType === void 0) throw new Error(`defineStyleProp: cssType is required for custom CSS properties (got cssProperty=${JSON.stringify(cssProperty)}).`);
-	if (!isCustomProperty && cssType !== void 0) throw new Error(`defineStyleProp: cssType is only allowed for custom CSS properties (--*). Got cssProperty=${JSON.stringify(cssProperty)} with cssType=${JSON.stringify(cssType)}.`);
-	const baseFields = {
-		kind: "styleProp",
-		cssProperty,
-		classPrefix,
-		values: values ?? [],
-		arbitrary,
-		cssType
-	};
-	const buildChainable = (fields) => {
-		const metadata = (meta = {}) => ({
-			...fields,
-			metadata: meta
-		});
-		const withOpacity = (spec) => buildChainable({
-			...fields,
-			opacityPair: {
-				as: spec.as,
-				values: spec.values,
-				separator: spec.separator ?? "_"
-			}
-		});
-		return {
-			...fields,
-			metadata,
-			withOpacity
-		};
-	};
-	return buildChainable(baseFields);
-}
-//#endregion
-export { defineStyleProp };

package/dist/config/dist/preset-merge.js

@@ -1,192 +0,0 @@
-import { validateComponentVariants } from "./component-resolution.js";
-//#region ../config/dist/preset-merge.js
-const defaultComponentDefinitionMergeStrategy = {
-	tokens: "preserve",
-	modes: "merge",
-	modifiers: "merge",
-	motion: "merge",
-	components: "merge",
-	globalStyles: "merge",
-	examples: "merge"
-};
-function flattenAtomic(atomic) {
-	const entries = [];
-	for (const group of atomic) for (const property of group.properties) for (const token of group.tokens) entries.push({
-		property,
-		cssPrefix: group.cssPrefix,
-		namespace: group.namespace,
-		groupType: group.type,
-		groupDescription: group.description,
-		token
-	});
-	return entries;
-}
-function tokenKey(entry) {
-	return `${entry.property}|${entry.cssPrefix ?? ""}|${entry.token.name}`;
-}
-function mergeAtomic(base, incoming, mode) {
-	if (incoming.length === 0) return base;
-	if (base.length === 0) return incoming;
-	const baseEntries = flattenAtomic(base);
-	const incomingEntries = flattenAtomic(incoming);
-	const merged = /* @__PURE__ */ new Map();
-	for (const entry of baseEntries) merged.set(tokenKey(entry), entry);
-	for (const entry of incomingEntries) {
-		const key = tokenKey(entry);
-		if (mode === "preserve" && merged.has(key)) continue;
-		merged.set(key, entry);
-	}
-	const regrouped = /* @__PURE__ */ new Map();
-	for (const entry of merged.values()) {
-		const groupKey = `${entry.property}|${entry.cssPrefix ?? ""}`;
-		const existing = regrouped.get(groupKey);
-		if (existing) {
-			existing.tokens.push(entry.token);
-			if (entry.groupType) existing.type = entry.groupType;
-			if (entry.groupDescription) existing.description = entry.groupDescription;
-			continue;
-		}
-		regrouped.set(groupKey, {
-			properties: [entry.property],
-			...entry.namespace ? { namespace: entry.namespace } : {},
-			...entry.cssPrefix ? { cssPrefix: entry.cssPrefix } : {},
-			...entry.groupType ? { type: entry.groupType } : {},
-			...entry.groupDescription ? { description: entry.groupDescription } : {},
-			tokens: [entry.token]
-		});
-	}
-	return Array.from(regrouped.values());
-}
-function mergeModes(base, incoming, mode) {
-	if (incoming.length === 0) return base;
-	if (base.length === 0) return incoming;
-	const result = [...base];
-	for (const nextGroup of incoming) {
-		const idx = result.findIndex((g) => g.name === nextGroup.name);
-		if (idx === -1) {
-			result.push(nextGroup);
-			continue;
-		}
-		if (mode === "preserve") continue;
-		if (mode === "override") {
-			result[idx] = nextGroup;
-			continue;
-		}
-		const current = result[idx];
-		const optionMap = new Map(current.options.map((opt) => [opt.modifier, opt]));
-		for (const opt of nextGroup.options) optionMap.set(opt.modifier, opt);
-		result[idx] = {
-			...current,
-			options: Array.from(optionMap.values())
-		};
-	}
-	return result;
-}
-function mergeModifiers(base, incoming, mode) {
-	if (incoming.length === 0) return base;
-	if (base.length === 0) return incoming;
-	const result = new Map(base.map((m) => [m.modifier, m]));
-	for (const def of incoming) {
-		if (mode === "preserve" && result.has(def.modifier)) continue;
-		result.set(def.modifier, def);
-	}
-	return Array.from(result.values());
-}
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function deepMerge(base, incoming) {
-	const out = { ...base };
-	for (const [key, value] of Object.entries(incoming)) {
-		const current = out[key];
-		if (isPlainObject(current) && isPlainObject(value)) out[key] = deepMerge(current, value);
-		else out[key] = value;
-	}
-	return out;
-}
-function mergeRecordByKey(base, incoming, mode) {
-	if (mode === "merge") {
-		const merged = { ...base };
-		for (const [key, value] of Object.entries(incoming)) {
-			const current = merged[key];
-			if (isPlainObject(current) && isPlainObject(value)) merged[key] = deepMerge(current, value);
-			else merged[key] = value;
-		}
-		return merged;
-	}
-	if (mode === "preserve") return {
-		...incoming,
-		...base
-	};
-	return {
-		...base,
-		...incoming
-	};
-}
-function applyPresetToData(base, preset, strategy) {
-	const s = {
-		...defaultComponentDefinitionMergeStrategy,
-		...strategy
-	};
-	const mergedExamples = base.examples || preset.examples ? mergeRecordByKey(base.examples ?? {}, preset.examples ?? {}, s.examples) : void 0;
-	const mergedPrinciples = base.designPrinciples || preset.designPrinciples ? [...base.designPrinciples ?? [], ...preset.designPrinciples ?? []] : void 0;
-	const mergedVars = base.vars || preset.vars ? mergeRecordByKey(base.vars ?? {}, preset.vars ?? {}, "merge") : void 0;
-	const mergedStyleProps = base.styleProps || preset.styleProps ? {
-		...base.styleProps ?? {},
-		...preset.styleProps ?? {}
-	} : void 0;
-	const merged = {
-		...base,
-		modes: mergeModes(base.modes, preset.modes, s.modes),
-		modifiers: mergeModifiers(base.modifiers, preset.modifiers, s.modifiers),
-		atomic: mergeAtomic(base.atomic, preset.atomic, s.tokens),
-		compositeStyles: {
-			...base.compositeStyles,
-			...preset.compositeStyles
-		},
-		motion: mergeRecordByKey(base.motion, preset.motion, s.motion),
-		components: mergeRecordByKey(base.components, preset.components, s.components),
-		globalStyles: mergeRecordByKey(base.globalStyles, preset.globalStyles, s.globalStyles),
-		examples: mergedExamples,
-		designPrinciples: mergedPrinciples,
-		vars: mergedVars,
-		styleProps: mergedStyleProps,
-		presetTokenNames: mergePresetTokenNames(base, preset)
-	};
-	validateComponentVariants(merged.components);
-	return merged;
-}
-/**
-* Union preset-contributed token names by namespace.
-*
-* Every token in `preset.vars`, `preset.atomic`, and `preset.presetTokenNames`
-* (from a nested compose) is added to the set. The set only grows — a later
-* local `.defineVars()` does NOT remove entries, which is what gives preset
-* tokens their read-only identity even when locally overridden.
-*/
-function mergePresetTokenNames(base, preset) {
-	const result = {};
-	for (const [ns, names] of Object.entries(base.presetTokenNames ?? {})) result[ns] = new Set(names);
-	const add = (ns, name) => {
-		if (name.startsWith("$")) return;
-		let set = result[ns];
-		if (!set) {
-			set = /* @__PURE__ */ new Set();
-			result[ns] = set;
-		}
-		set.add(name);
-	};
-	if (preset.vars) for (const [ns, group] of Object.entries(preset.vars)) for (const name of Object.keys(group)) add(ns, name);
-	if (preset.presetTokenNames) for (const [ns, names] of Object.entries(preset.presetTokenNames)) for (const name of names) add(ns, name);
-	if (preset.atomic) for (const group of preset.atomic) {
-		const ns = group.cssPrefix;
-		if (!ns) continue;
-		for (const token of group.tokens) add(ns, token.name);
-	}
-	if (Object.keys(result).length === 0) return void 0;
-	const out = {};
-	for (const [ns, set] of Object.entries(result)) out[ns] = [...set];
-	return out;
-}
-//#endregion
-export { applyPresetToData, deepMerge, mergeAtomic };

package/dist/config/dist/propertyAcceptedTypes.js

@@ -1,220 +0,0 @@
-//#region ../config/dist/propertyAcceptedTypes.js
-const LENGTH_PCT = { types: [
-	"length",
-	"percentage",
-	"length-percentage"
-] };
-const LENGTH_PCT_AUTO = {
-	types: [
-		"length",
-		"percentage",
-		"length-percentage"
-	],
-	literals: ["auto"]
-};
-const SIZING = {
-	types: [
-		"length",
-		"percentage",
-		"length-percentage"
-	],
-	literals: [
-		"auto",
-		"min-content",
-		"max-content",
-		"fit-content"
-	]
-};
-const SIZING_WITH_NONE = {
-	types: [
-		"length",
-		"percentage",
-		"length-percentage"
-	],
-	literals: [
-		"auto",
-		"min-content",
-		"max-content",
-		"fit-content",
-		"none"
-	]
-};
-const LENGTH_ONLY = { types: ["length"] };
-const COLOR_ONLY = {
-	types: ["color"],
-	literals: ["transparent", "currentColor"]
-};
-const TIME_ONLY = { types: ["time"] };
-const NUMBER_ONLY = { types: ["number", "integer"] };
-const ANGLE_ONLY = { types: ["angle"] };
-/**
-* CSS-wide keywords — accepted on every CSS property per the CSS spec.
-* Synthesizer marks these as `$type: 'string'` so they don't match the
-* property's type-based accept rule; they pass via this set instead.
-*/
-const CSS_WIDE_KEYWORDS = new Set([
-	"inherit",
-	"initial",
-	"unset",
-	"revert",
-	"revert-layer",
-	"transparent",
-	"currentColor",
-	"currentcolor"
-]);
-const LENGTH_PCT_PROPS = [
-	"gap",
-	"column-gap",
-	"row-gap",
-	"padding",
-	"padding-top",
-	"padding-right",
-	"padding-bottom",
-	"padding-left",
-	"padding-block",
-	"padding-inline",
-	"padding-inline-start",
-	"padding-inline-end",
-	"scroll-margin",
-	"scroll-margin-top",
-	"scroll-margin-bottom",
-	"scroll-margin-block",
-	"scroll-margin-inline",
-	"scroll-margin-inline-start",
-	"scroll-margin-inline-end",
-	"scroll-padding",
-	"scroll-padding-top",
-	"scroll-padding-bottom",
-	"scroll-padding-block",
-	"scroll-padding-inline",
-	"scroll-padding-inline-start",
-	"scroll-padding-inline-end",
-	"border-radius",
-	"border-top-left-radius",
-	"border-top-right-radius",
-	"border-bottom-left-radius",
-	"border-bottom-right-radius",
-	"border-start-start-radius",
-	"border-start-end-radius",
-	"border-end-start-radius",
-	"border-end-end-radius",
-	"text-indent",
-	"font-size"
-];
-const LENGTH_PCT_AUTO_PROPS = [
-	"margin",
-	"margin-top",
-	"margin-right",
-	"margin-bottom",
-	"margin-left",
-	"margin-block",
-	"margin-inline",
-	"margin-inline-start",
-	"margin-inline-end",
-	"top",
-	"right",
-	"bottom",
-	"left",
-	"inset",
-	"inset-block",
-	"inset-inline"
-];
-const SIZING_PROPS = [
-	"width",
-	"height",
-	"min-width",
-	"min-height"
-];
-const SIZING_WITH_NONE_PROPS = ["max-width", "max-height"];
-const LENGTH_ONLY_PROPS = [
-	"border-width",
-	"border-top-width",
-	"border-right-width",
-	"border-bottom-width",
-	"border-left-width",
-	"border-block-width",
-	"border-inline-width",
-	"border-inline-start-width",
-	"border-inline-end-width",
-	"outline-width",
-	"outline-offset",
-	"border-spacing",
-	"letter-spacing",
-	"text-underline-offset",
-	"text-decoration-thickness"
-];
-const COLOR_PROPS = [
-	"color",
-	"background-color",
-	"border-color",
-	"border-top-color",
-	"border-right-color",
-	"border-bottom-color",
-	"border-left-color",
-	"border-block-color",
-	"border-inline-color",
-	"border-inline-start-color",
-	"border-inline-end-color",
-	"outline-color",
-	"text-decoration-color",
-	"caret-color",
-	"fill",
-	"stroke"
-];
-const TIME_PROPS = ["transition-duration", "transition-delay"];
-const NUMBER_PROPS = [
-	"flex-grow",
-	"flex-shrink",
-	"order",
-	"z-index",
-	"-webkit-line-clamp"
-];
-const ANGLE_PROPS = ["rotate"];
-const PROPERTY_ACCEPTED_TYPES = new Map([
-	...LENGTH_PCT_PROPS.map((p) => [p, LENGTH_PCT]),
-	...LENGTH_PCT_AUTO_PROPS.map((p) => [p, LENGTH_PCT_AUTO]),
-	...SIZING_PROPS.map((p) => [p, SIZING]),
-	...SIZING_WITH_NONE_PROPS.map((p) => [p, SIZING_WITH_NONE]),
-	...LENGTH_ONLY_PROPS.map((p) => [p, LENGTH_ONLY]),
-	...COLOR_PROPS.map((p) => [p, COLOR_ONLY]),
-	...TIME_PROPS.map((p) => [p, TIME_ONLY]),
-	...NUMBER_PROPS.map((p) => [p, NUMBER_ONLY]),
-	...ANGLE_PROPS.map((p) => [p, ANGLE_ONLY]),
-	["font-weight", { types: [
-		"font-weight",
-		"number",
-		"integer"
-	] }],
-	["font-family", { types: ["font-family"] }],
-	["transition-timing-function", { types: ["easing-function"] }],
-	["box-shadow", {
-		types: ["shadow"],
-		literals: ["none"]
-	}],
-	["text-shadow", {
-		types: ["shadow"],
-		literals: ["none"]
-	}],
-	["list-style-image", { types: ["url", "image"] }],
-	["aspect-ratio", { types: ["ratio", "number"] }],
-	["opacity", { types: ["number", "percentage"] }],
-	["z-index", {
-		types: ["integer", "number"],
-		literals: ["auto"]
-	}]
-]);
-/**
-* Whether a token with the given detected value type AND raw string value
-* is accepted by the CSS property. Returns `true` for any property not in
-* the table.
-*/
-function isTokenAcceptedByProperty(cssProperty, valueType, rawValue) {
-	if (CSS_WIDE_KEYWORDS.has(rawValue)) return true;
-	const entry = PROPERTY_ACCEPTED_TYPES.get(cssProperty);
-	if (!entry) return true;
-	if (valueType && entry.types?.includes(valueType)) return true;
-	if (entry.literals?.includes(rawValue)) return true;
-	return false;
-}
-//#endregion
-export { PROPERTY_ACCEPTED_TYPES, isTokenAcceptedByProperty };

package/dist/config/dist/propertyGroups.d.ts

@@ -1 +0,0 @@
-import { ConfigurableProp } from "@uds/types";