@yahoo/uds-create-config 5.68.2 → 5.68.3

package/dist/entities/documentation/Documentation.d.ts

@@ -15,8 +15,8 @@ declare const DocumentationDefinition: EntityClass<z.ZodObject<{
     uds: "uds";
   }>>;
   platform: z.ZodOptional<z.ZodEnum<{
-    mobile: "mobile";
     web: "web";
+    mobile: "mobile";
   }>>;
 }, z.core.$strict>, z.ZodObject<Record<never, never>, z.core.$strip>, "documentation", {
   readonly search: {

package/dist/entities/system/defineComponent.d.ts

@@ -14,9 +14,8 @@ import { AllHTMLAttributes, ComponentPropsWithRef, ComponentType, ElementType, J
  * Enough of another component to BE a layer's element — the handle `defineComponent` returns, with
  * its declarations forgotten so a builder of any shape fits.
  *
- * Named separately from `AuthoredComponent` because that one fixes the declarations at their widest,
- * and a layer must keep the ones the referenced component actually made: they're where its props come
- * from. `ComponentBuilder<{root:'button'}, …>` satisfies this; it does not satisfy `AuthoredComponent`.
+ * Named separately from `AuthoredComponent`, which is what a registry holds; a layer only needs to know
+ * the value is a component, and keeps the referenced component's own type for its props.
  */
 interface ComponentElement extends Authored {
   readonly kind: 'component';
@@ -582,11 +581,13 @@ type OpenTail<L extends LayerMap> = Registered extends true ? StyleProps & Modif
  */
 type ComponentPropsOf<L extends LayerMap, P extends PropMap, D = Record<never, never>, E = Record<never, never>, F extends string = never, As = never> = ConsumerDeclaredProps<P, D, E, L, ComponentBuilder<L, P, E, D, F>> & Partial<E> & Redeclared<RootSurface<L, D, As>, P, E> & Redeclared<ForwardedPropsOf<L, F>, P, E> & AsPropsOf<As, P, E> & Redeclared<OpenTail<L>, P, E>;
 /**
- * `T` less the keys the component declares and the keys its render extra names — each taken out on
- * its own, because {@link Without} leaves `T` whole when the key set is open, and an open render
- * extra (`extends Record<string, unknown>`) must not stop the declared props from shadowing.
+ * `T` less the keys the component declares and the keys its render extra names. {@link Without} leaves
+ * `T` whole when its key set is open, so an open set of either kind is left out of the union rather
+ * than opening it: an open render extra (`extends Record<string, unknown>`) must not stop the declared
+ * props from shadowing. Both sets come out in one mapped type, since this runs once per component over
+ * every style prop and modifier the system registers.
  */
-type Redeclared<T, P, E> = Without<Without<T, keyof P>, Redefined<E>>;
+type Redeclared<T, P, E> = string extends Redefined<E> ? Without<T, keyof P> : string extends keyof P ? Without<T, Redefined<E>> : Without<T, keyof P | Redefined<E>>;
 /**
  * The phantom call signature's parameter. `As` is inferred from `as` alone; the rest of the surface
  * is `NoInfer`, so inference never walks it. Open to inference, a spread of
@@ -642,7 +643,13 @@ type IntrinsicAttributeNames<As> = As extends keyof JSX.IntrinsicElements ? keyo
  * there is no telling a stray attribute from a style prop, and an unbuilt consumer compiles the way
  * the registry promises.
  */
-type ForeignAttributesOf<As, P, E> = Registered extends false ? Record<never, never> : [As] extends [keyof JSX.IntrinsicElements] ? { [K in Exclude<keyof AllHTMLAttributes<HTMLElement>, 'as' | IntrinsicAttributeNames<As> | keyof P | keyof E | keyof RegisteredStyleProps>]?: never } : Record<never, never>;
+type ForeignAttributesOf<As, P, E> = Registered extends false ? Record<never, never> : [As] extends [keyof JSX.IntrinsicElements] ? { [K in Exclude<AttributeNames, IntrinsicAttributeNames<As> | keyof P | keyof E>]?: never } : Record<never, never>;
+/**
+ * The HTML attribute names less `as` and the registered style props, which are the same for every
+ * component. A single `Exclude` over this concrete union takes out the rest: one over a deferred
+ * `Exclude<…, IntrinsicAttributeNames<As>>` would build an intersection per name while `As` is generic.
+ */
+type AttributeNames = Exclude<keyof AllHTMLAttributes<HTMLElement>, 'as' | keyof RegisteredStyleProps>;
 /**
  * The props a component picks up from the layers it FORWARDS.
  *
@@ -753,19 +760,24 @@ type WhenAny<K, T> = [K] extends [never] ? unknown : T;
  * with `P` in full as its type argument.
  */
 type CompactProps<P extends PropMap> = [StyleRefKeys<P> | StyleRefPropKeys<P>] extends [never] ? P : { [K in keyof P as K extends StyleRefKeys<P> | StyleRefPropKeys<P> ? never : K]: P[K] } & WhenAny<StyleRefKeys<P>, StyleRefs<StyleRefKeys<P> & string>> & WhenAny<StyleRefPropKeys<P>, StyleRefProps<StyleRefPropKeys<P> & string>>;
-interface ComponentBuilder<L extends LayerMap, P extends PropMap,
+/**
+ * Every type parameter is declared `in out`. Measured instead, TypeScript relates two instantiations
+ * with `P` generic, which crosses every registered style prop and modifier name with every other, and
+ * past 316 of them that is over its 100,000-member union limit (TS2590).
+ */
+interface ComponentBuilder<in out L extends LayerMap, in out P extends PropMap,
 /** Props the RENDER takes that the config doesn't describe — React handlers, mostly (`onPress`).
  *  They're part of the component's surface but not of its data, which is why they're declared at
  *  `.render()` rather than in `.props()`. */
-E = Record<never, never>,
+in out E = Record<never, never>,
 /** The defaults as AUTHORED, kept because one of them decides the type of every other prop: an
  *  `as` fixes which element this renders. See {@link ElementOf}. */
-D = Record<never, never>,
+in out D = Record<never, never>,
 /** The layers this component FORWARDS from, as a union of their names. Accumulates through
  *  `.forwards()` so `ComponentPropsOf` can union each forwarded layer's element props — `root` is
  *  already covered structurally by {@link ElementOf}, so for a root-only forward this changes no
  *  inferred type, which is what makes replacing `inherits` a no-op at every call site. */
-F extends string = never, /** The states `.states()` declared — what the render knows and reports, never a caller's prop. */S extends StateMap = Record<never, never>> extends Authored {
+in out F extends string = never, /** The states `.states()` declared — what the render knows and reports, never a caller's prop. */in out S extends StateMap = Record<never, never>> extends Authored {
   /**
    * The phantom call signature — the authored value is never rendered (the build substitutes the
    * emitted module), but a call site is checked against it. Generic over the element a call site
@@ -884,8 +896,19 @@ F extends string = never, /** The states `.states()` declared — what the rende
   toStored(): Record<string, unknown>;
   assignPath(path: string): void;
 }
-/** A component under authorship, with its declarations forgotten — what a registry holds. */
-type AuthoredComponent = ComponentBuilder<LayerMap, PropMap, unknown, unknown>;
+/**
+ * A component under authorship, with its declarations forgotten — what a registry holds. It names only
+ * the members every builder has with the same type, so a builder of any shape is assignable to it.
+ */
+interface AuthoredComponent extends Authored {
+  readonly kind: 'component';
+  readonly body: Record<string, unknown>;
+  readonly path?: string;
+  toStored(): Record<string, unknown>;
+  assignPath(path: string): void;
+}
+/** What the whole-body form returns: a builder whose declarations are all at their widest. */
+type WidestComponentBuilder = ComponentBuilder<LayerMap, PropMap, unknown, unknown>;
 /**
  * A linked component's handle as the system that links it holds it. The build emits one for each
  * linked component the link changes, and the system's linked alias resolves to it first (UDS-4611).
@@ -931,7 +954,7 @@ interface DefineComponent {
     root: El;
   }, Record<never, never>>;
   /** The whole body at once, for a component with nothing to narrow step by step. */
-  (body?: ComponentSourceInput<Record<string, unknown>>): AuthoredComponent;
+  (body?: ComponentSourceInput<Record<string, unknown>>): WidestComponentBuilder;
   layers<const L extends LayerMap>(layers: L): ComponentBuilder<L, Record<never, never>>;
   props: typeof definePropsFirst;
 }

package/dist/entities/system/defineComponent.js

@@ -402,24 +402,6 @@ function toStored(body) {
 		styles: storedStyleRules(rules)
 	};
 }
-/**
-* Author a component.
-*
-* Callable for the case with nothing to narrow — `defineComponent({ layers: { root: 'div' } })` — and
-* chainable for every other, since a chain is what lets each step's types come from the last.
-*/
-/**
-* Author a component.
-*
-* Called with an ELEMENT — `defineComponent('input')`, `defineComponent(Component.ref('Box'))` — that
-* element becomes the root layer, because a component with one layer IS that element and saying so
-* twice adds nothing. It's also what makes the element's props type correctly: v1 expressed this as a
-* `defaultProps: { as: 'input' }` on a `div`-rooted component, which left the config claiming the
-* element was a `div` while every call site treated it as an input.
-*
-* The render follows from it too — one layer needs no anatomy, so the build generates the element
-* rather than reading a `.render()` that would only restate the layer.
-*/
 function defineComponentImpl(bodyOrElement) {
 	if (isComponentElement(bodyOrElement)) return build({ layers: { root: bodyOrElement } });
 	if (typeof bodyOrElement === "function" || isRef(bodyOrElement) && kindOf(bodyOrElement) === "package") throw new Error("[uds] defineComponent(<package export>): a package export cannot be a component's only layer yet — the generated one-layer render emits web elements. Declare `layers` and a `.render()` instead.");