@yahoo/uds-create-config 5.68.3 → 5.68.5

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

@@ -496,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.
  *
@@ -507,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.
  *
@@ -564,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.
  *
@@ -579,15 +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. {@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.
+ * props from shadowing.
+ */
+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 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>>;
+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
@@ -663,7 +686,7 @@ type AttributeNames = Exclude<keyof AllHTMLAttributes<HTMLElement>, 'as' | keyof
  * 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.