@yahoo/uds-create-config 5.57.0 → 5.58.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yahoo/uds-create-config",
-  "version": "5.57.0",
+  "version": "5.58.0",
   "private": false,
   "type": "module",
   "main": "./dist/index.js",

package/dist/entities/system/conditional-defaults.d.ts

@@ -1,67 +0,0 @@
-import { StoredDefaultCondition } from "../../framework/default-conditions.js";
-
-//#region src/entities/system/conditional-defaults.d.ts
-declare const CONDITIONAL_DEFAULT: unique symbol;
-/** One condition of a {@link ConditionalDefault}: the value the prop defaults to while `when` holds. */
-interface ConditionalDefaultEntry<V = unknown> {
-  readonly when: Readonly<Record<string, unknown>>;
-  readonly value: V;
-}
-/** A default chosen by the component's other props — see {@link conditionalDefault}. */
-interface ConditionalDefault<V = unknown> {
-  readonly [CONDITIONAL_DEFAULT]: true;
-  readonly fallback: V;
-  readonly entries: readonly ConditionalDefaultEntry<V>[];
-}
-/**
- * A default that depends on the component's other props, for `.defaultProps` and
- * `.extend({ defaultProps })` only.
- *
- * ```ts
- * .defaultProps({
- *   modal: true,
- *   includeScrim: conditionalDefault(true, [{ when: { modal: false }, value: false }]),
- * })
- * ```
- *
- * `fallback` applies when no entry's `when` holds; when several hold, the later entry wins. A `when`
- * is the grammar a style rule uses, over the component's own props. A value the call site passes
- * still wins over any of it.
- */
-declare function conditionalDefault<const V>(fallback: V, entries: readonly ConditionalDefaultEntry<V>[]): ConditionalDefault<V>;
-declare function isConditionalDefault(value: unknown): value is ConditionalDefault;
-/**
- * Stored defaults as authored: the inverse of {@link splitConditionalDefaults}, each prop
- * `defaultPropsWhen` names given back as a {@link conditionalDefault} over its fallback.
- */
-declare function joinConditionalDefaults({
-  defaultProps,
-  defaultPropsWhen
-}: {
-  defaultProps: Readonly<Record<string, unknown>> | undefined;
-  defaultPropsWhen: Readonly<Record<string, StoredDefaultCondition>> | undefined;
-}): Record<string, unknown>;
-/** The conditions one prop defaults under, in stored order, as `conditionalDefault` entries. */
-declare function propDefaultConditions({
-  defaultPropsWhen,
-  prop
-}: {
-  defaultPropsWhen: Readonly<Record<string, StoredDefaultCondition>> | undefined;
-  prop: string;
-}): ConditionalDefaultEntry[];
-/**
- * `defaultPropsWhen` with one prop's conditions replaced by `entries`: the prop leaves every entry it
- * was in, an entry left setting nothing goes, and each new condition joins the entry already keyed
- * by it or is added at the end. What a surface editing one prop's conditions writes back whole.
- */
-declare function withPropDefaultConditions({
-  defaultPropsWhen,
-  prop,
-  entries
-}: {
-  defaultPropsWhen: Readonly<Record<string, StoredDefaultCondition>> | undefined;
-  prop: string;
-  entries: readonly ConditionalDefaultEntry[];
-}): Record<string, StoredDefaultCondition>;
-//#endregion
-export { ConditionalDefault, ConditionalDefaultEntry, conditionalDefault, isConditionalDefault, joinConditionalDefaults, propDefaultConditions, withPropDefaultConditions };

package/dist/entities/system/conditional-defaults.js

@@ -1,179 +0,0 @@
-import { isPlainObject } from "../../framework/utils/field-path.js";
-import { canonicalCondition } from "../../framework/utils/refs.js";
-//#region src/entities/system/conditional-defaults.ts
-const CONDITIONAL_DEFAULT = Symbol.for("uds.conditionalDefault");
-/**
-* A default that depends on the component's other props, for `.defaultProps` and
-* `.extend({ defaultProps })` only.
-*
-* ```ts
-* .defaultProps({
-*   modal: true,
-*   includeScrim: conditionalDefault(true, [{ when: { modal: false }, value: false }]),
-* })
-* ```
-*
-* `fallback` applies when no entry's `when` holds; when several hold, the later entry wins. A `when`
-* is the grammar a style rule uses, over the component's own props. A value the call site passes
-* still wins over any of it.
-*/
-function conditionalDefault(fallback, entries) {
-	return {
-		[CONDITIONAL_DEFAULT]: true,
-		fallback,
-		entries
-	};
-}
-function isConditionalDefault(value) {
-	return typeof value === "object" && value !== null && value[CONDITIONAL_DEFAULT] === true;
-}
-/**
-* Authored defaults as stored: each {@link conditionalDefault} leaves its fallback in `defaultProps`
-* and its entries in `defaultPropsWhen`. `defaultPropsWhen` is `undefined` when nothing was
-* conditional, so a body without one stores exactly what it did before.
-*
-* Stored by condition, every prop shares one order of conditions, while precedence is per prop. The
-* order taken keeps each prop's own; two props that order the same two conditions oppositely can't
-* share one, and are refused.
-*/
-function splitConditionalDefaults(authored) {
-	const defaultProps = {};
-	const perProp = /* @__PURE__ */ new Map();
-	for (const [prop, value] of Object.entries(authored)) {
-		if (!isConditionalDefault(value)) {
-			defaultProps[prop] = value;
-			continue;
-		}
-		if (value.fallback !== void 0) defaultProps[prop] = value.fallback;
-		const entries = /* @__PURE__ */ new Map();
-		for (const entry of value.entries) {
-			const key = canonicalCondition(entry.when);
-			entries.delete(key);
-			entries.set(key, entry);
-		}
-		perProp.set(prop, entries);
-	}
-	if (perProp.size === 0) return { defaultProps };
-	const order = conditionOrder(perProp);
-	const defaultPropsWhen = {};
-	for (const key of order) {
-		let when;
-		const props = {};
-		for (const [prop, entries] of perProp) {
-			const entry = entries.get(key);
-			if (!entry) continue;
-			when ??= { ...entry.when };
-			props[prop] = entry.value;
-		}
-		if (when) defaultPropsWhen[key] = {
-			when,
-			props
-		};
-	}
-	return {
-		defaultProps,
-		defaultPropsWhen
-	};
-}
-/**
-* `defaultProps` as stored: each `conditionalDefault` splits into its fallback, which stays in
-* `defaultProps`, and its conditions, which go to `defaultPropsWhen`. Empty for a body whose
-* defaults are all plain, so it stores what it did before.
-*/
-function storedDefaults(body) {
-	if (!isPlainObject(body.defaultProps)) return {};
-	const { defaultProps, defaultPropsWhen } = splitConditionalDefaults(body.defaultProps);
-	return defaultPropsWhen ? {
-		defaultProps,
-		defaultPropsWhen
-	} : {};
-}
-/**
-* One order of every condition that keeps each prop's own order, by first appearance where props
-* don't constrain it.
-*/
-function conditionOrder(perProp) {
-	const seen = [];
-	const after = /* @__PURE__ */ new Map();
-	for (const [prop, entries] of perProp) {
-		const keys = [...entries.keys()];
-		keys.forEach((key, at) => {
-			if (!seen.includes(key)) seen.push(key);
-			const earlier = after.get(key) ?? /* @__PURE__ */ new Map();
-			for (const before of keys.slice(0, at)) earlier.set(before, prop);
-			after.set(key, earlier);
-		});
-	}
-	for (const [key, earlier] of after) for (const [before, prop] of earlier) {
-		const other = after.get(before)?.get(key);
-		if (other === void 0) continue;
-		throw new Error(`\`${prop}\` puts \`${before}\` before \`${key}\` and \`${other}\` puts them the other way round. Conditional defaults share one order of conditions, so give both props the same order.`);
-	}
-	const order = [];
-	const placed = /* @__PURE__ */ new Set();
-	const placing = /* @__PURE__ */ new Set();
-	const place = (key) => {
-		if (placed.has(key)) return;
-		if (placing.has(key)) throw new Error(`Conditional defaults order \`${key}\` both before and after another condition across their props. They share one order of conditions, so give every prop the same order.`);
-		placing.add(key);
-		for (const before of after.get(key)?.keys() ?? []) place(before);
-		placing.delete(key);
-		placed.add(key);
-		order.push(key);
-	};
-	for (const key of seen) place(key);
-	return order;
-}
-/**
-* Stored defaults as authored: the inverse of {@link splitConditionalDefaults}, each prop
-* `defaultPropsWhen` names given back as a {@link conditionalDefault} over its fallback.
-*/
-function joinConditionalDefaults({ defaultProps, defaultPropsWhen }) {
-	const out = { ...defaultProps };
-	const entries = /* @__PURE__ */ new Map();
-	for (const { when, props } of Object.values(defaultPropsWhen ?? {})) for (const [prop, value] of Object.entries(props ?? {})) entries.set(prop, [...entries.get(prop) ?? [], {
-		when,
-		value
-	}]);
-	for (const [prop, list] of entries) out[prop] = conditionalDefault(out[prop], list);
-	return out;
-}
-/** The conditions one prop defaults under, in stored order, as `conditionalDefault` entries. */
-function propDefaultConditions({ defaultPropsWhen, prop }) {
-	return Object.values(defaultPropsWhen ?? {}).flatMap(({ when, props }) => props && Object.hasOwn(props, prop) ? [{
-		when,
-		value: props[prop]
-	}] : []);
-}
-/**
-* `defaultPropsWhen` with one prop's conditions replaced by `entries`: the prop leaves every entry it
-* was in, an entry left setting nothing goes, and each new condition joins the entry already keyed
-* by it or is added at the end. What a surface editing one prop's conditions writes back whole.
-*/
-function withPropDefaultConditions({ defaultPropsWhen, prop, entries }) {
-	const out = {};
-	for (const [key, { when, props }] of Object.entries(defaultPropsWhen ?? {})) {
-		const { [prop]: _left, ...rest } = props ?? {};
-		if (Object.keys(rest).length > 0) out[key] = {
-			when,
-			props: rest
-		};
-	}
-	for (const entry of entries) {
-		const key = canonicalCondition(entry.when);
-		const existing = out[key];
-		out[key] = existing ? {
-			...existing,
-			props: {
-				...existing.props,
-				[prop]: entry.value
-			}
-		} : {
-			when: { ...entry.when },
-			props: { [prop]: entry.value }
-		};
-	}
-	return out;
-}
-//#endregion
-export { conditionalDefault, isConditionalDefault, joinConditionalDefaults, propDefaultConditions, storedDefaults, withPropDefaultConditions };