@yahoo/uds-create-config 5.68.2 → 5.68.4

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';
@@ -497,7 +496,20 @@ type AsInput = ElementType | string;
  */
 type UnionToIntersection<U> = (U extends unknown ? (member: U) => void : never) extends ((member: infer I) => void) ? I : never;
 /** One element's contribution, a union of tags folded into one object type. */
-type ElementSurface<Element> = UnionToIntersection<ElementPropsOf<Element>>;
+type ElementSurface<Element> = UnionToIntersection<SurfacePropsOf<Element>>;
+/**
+ * {@link ElementPropsOf} as a surface takes it, beside the system's tail: a component's props less the
+ * style props and modifiers it takes from that tail unchanged, which are the ones it neither declares
+ * nor redefines in its render extra. The surface intersects the tail anyway, so each of those has the
+ * same type and modifiers either way, and it isn't declared twice in every component's props.
+ */
+type SurfacePropsOf<Element> = Element extends keyof JSX.IntrinsicElements ? ElementPropsOf<Element> : Element extends ((props: infer PropsOfComponent) => unknown) ? Element extends {
+  metadata(meta: never): infer Builder;
+} ? Builder extends ComponentBuilder<infer _L extends LayerMap, infer P extends PropMap, infer E, infer _D, infer _F extends string, infer _S extends StateMap> ? DeclaredExcept<PropsOfComponent, Exclude<keyof SystemTail, RedeclaredKeys<P, E>>> : Declared<PropsOfComponent> : Declared<PropsOfComponent> : Element extends {
+  readonly __ref: `component:${infer Path}`;
+} ? Path extends keyof RegisteredComponentHandles ? SurfacePropsOf<RegisteredComponentHandles[Path]> : Record<never, never> : Record<never, never>;
+/** {@link Declared}, less the keys in `K`. */
+type DeclaredExcept<T, K> = { [Key in keyof T as string extends Key ? never : number extends Key ? never : Key extends K ? never : Key]: T[Key] };
 /**
  * What the root layer contributes to the surface.
  *
@@ -508,7 +520,7 @@ type ElementSurface<Element> = UnionToIntersection<ElementPropsOf<Element>>;
  * than intersected, or a handler is typed against both elements when only one renders. A style
  * prop the root declares is not an element key (see {@link ElementPropsOf}), so it survives the swap.
  */
-type RootSurface<L extends LayerMap, D, As> = [RenderedElementOf<L, D, As>] extends [L['root']] ? ElementSurface<L['root']> : Without<ElementSurface<L['root']>, keyof ElementSurface<RenderedElementOf<L, D, As>>> & ElementSurface<RenderedElementOf<L, D, As>>;
+type RootSurface<L extends LayerMap, D, As> = [RenderedElementOf<L, D, As>] extends [L['root']] ? ElementSurface<L['root']> : Without<ElementSurface<L['root']>, keyof UnionToIntersection<ElementPropsOf<RenderedElementOf<L, D, As>>>> & ElementSurface<RenderedElementOf<L, D, As>>;
 /**
  * The element one call renders: what its `as` names, else what the component fixes.
  *
@@ -565,8 +577,12 @@ type LayerProps<L extends LayerMap> = {
  *
  * Open before the build: which names are style props is the system's to say, and until its emitted
  * types say it, anything may be one.
+ *
+ * The style props and modifiers are one type for the whole system, kept apart from the layer channel,
+ * so a component that declares none of their names takes that type as it is.
  */
-type OpenTail<L extends LayerMap> = Registered extends true ? StyleProps & ModifierProps & LayerProps<L> : Record<string, unknown>;
+type OpenTail<L extends LayerMap, P, E> = Registered extends true ? Shadowed<SystemTail, RedeclaredKeys<P, E>> & Redeclared<LayerProps<L>, P, E> : Redeclared<Record<string, unknown>, P, E>;
+type SystemTail = StyleProps & ModifierProps;
 /**
  * The props a consumer may pass — the declared ones, the rendered element's, and the style props.
  *
@@ -580,13 +596,21 @@ type OpenTail<L extends LayerMap> = Registered extends true ? StyleProps & Modif
  *
  * Ends in {@link OpenTail}: the system's own surface, open until the system's build has named it.
  */
-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>;
+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> & Shadowed<ForwardedPropsOf<L, F>, RedeclaredKeys<P, E>> & AsPropsOf<As, P, E> & 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.
  */
-type Redeclared<T, P, E> = Without<Without<T, keyof P>, Redefined<E>>;
+type Redeclared<T, P, E> = Without<T, RedeclaredKeys<P, E>>;
+type RedeclaredKeys<P, E> = string extends Redefined<E> ? keyof P : string extends keyof P ? Redefined<E> : keyof P | Redefined<E>;
+/**
+ * `T` without the keys in `K` it has, and `T` itself when it has none of them. The system's tail is one
+ * type every component shares, and a mapped copy per component would cost the size of that type
+ * rather than the size of what the component declares.
+ */
+type Shadowed<T, K extends PropertyKey> = [Extract<K, keyof T>] extends [never] ? T : Without<T, Extract<K, keyof T>>;
 /**
  * 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 +666,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.
  *
@@ -656,7 +686,7 @@ type ForeignAttributesOf<As, P, E> = Registered extends false ? Record<never, ne
  * accept `HTMLDivElement | HTMLInputElement` instead of the input it actually receives.
  */
 type NonRootForward<L extends LayerMap, F extends string> = Exclude<F, 'root'> & keyof L;
-type ForwardedPropsOf<L extends LayerMap, F extends string> = [NonRootForward<L, F>] extends [never] ? Record<never, never> : Partial<ElementPropsOf<L[NonRootForward<L, F>]>>;
+type ForwardedPropsOf<L extends LayerMap, F extends string> = [NonRootForward<L, F>] extends [never] ? Record<never, never> : Partial<SurfacePropsOf<L[NonRootForward<L, F>]>>;
 /**
  * Defaults a component applies with nothing set — its declared props, typed, plus the style props it
  * may also default.
@@ -753,19 +783,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 +919,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 +977,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.");