@yahoo/uds-create-config 5.63.0 → 5.64.0

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

@@ -1,9 +1,9 @@
 import { Ref } from "../../framework/utils/refs.js";
 import { SourceResolver, SourceState } from "../../framework/sources.js";
 import { ComputedInput } from "../../framework/registry.js";
-import { RegisteredComponentContracts, RegisteredEntities } from "../../framework/registered.js";
+import { RegisteredComponentContracts, RegisteredEntities, RegisteredGroupPaths } from "../../framework/registered.js";
 import { EntityClass, ItemOf } from "../../framework/defineEntity.js";
-import { PartialBodyOf } from "../../framework/defineConfig.js";
+import { PartialBodyOf, PartialGroupBodyOf } from "../../framework/defineConfig.js";
 import { Named } from "../../framework/named.js";
 import { LayerMap, StyleRuleInput } from "./defineComponent.js";
 import { ContractStyleRules } from "./Component.js";
@@ -248,19 +248,39 @@ type PinOptions = { [A in keyof RegisteredEntities]?: Record<string, PinAdjustme
 /**
  * {@link PinOptions} as `LinkedSystem.item` takes it: a component entry's `override` and `extend` also
  * take their `styles` as the rule list `defineComponent.styles` takes (`[{ when?, layers }]`), which
- * the item stores as the record.
+ * the item stores as the record, and an entry at a group path takes the kind's group fields.
  *
- * `K` is the component paths the entries name, inferred at the call, which is what lets each entry be
- * checked against its own component: an index signature would type every path alike. A rule's layers
- * come from the contract `uds-env.d.ts` registers for that path (`Badge@yos`), and stay open where
- * none is registered yet, as a config that has not built keeps the open record.
+ * `K` is the paths the entries name, inferred at the call, which is what lets each entry be checked
+ * against its own path: an index signature would type every path alike. A rule's layers come from the
+ * contract `uds-env.d.ts` registers for that path (`Badge@yos`), and a group is a path it registers
+ * among `RegisteredGroupPaths`. Both stay open where nothing is registered yet, as a config that has
+ * not built keeps the open record.
  *
  * OPEN: the item does not know the slug it is declared under, so a path is matched against a contract
- * of that name from any source, and one registered by several is held to any one of theirs.
+ * or a group of that name from any source, and one registered by several is held to any one of theirs.
+ *
+ * OPEN: an item field at a group path still type-checks when the whole call also fits `item`'s
+ * overload for the stored body, whose {@link PinOptions} types every path as an item. A call with a
+ * rule-list `styles` doesn't fit it, so there the field is refused.
  */
 type PinOptionsInput<K extends string = string> = { [A in keyof RegisteredEntities]?: RegisteredEntities[A] extends {
   readonly kind: 'component';
-} ? { [P in K]?: PinComponentAdjustment<RegisteredEntities[A], P> } : Record<string, PinAdjustment<RegisteredEntities[A]>> };
+} ? { [P in K]?: PinPathAdjustment<RegisteredEntities[A], P, PinComponentAdjustment<RegisteredEntities[A], P>> } : { [P in K]?: PinPathAdjustment<RegisteredEntities[A], P, PinAdjustment<RegisteredEntities[A]>> } };
+/** The entry for one path of `E`'s kind: the group fields where `P` is a registered group, else
+ *  `Item`. A path is one or the other, never both. */
+type PinPathAdjustment<E, P extends string, Item> = string extends P ? Item : [RegisteredGroupOf<E, P>] extends [never] ? Item : PinGroupAdjustment<E>;
+/** The group paths registered for `E`'s kind that `P` names, as this config spells it or as a source
+ *  does (`spectrum@yos`). */
+type RegisteredGroupOf<E, P extends string> = E extends {
+  readonly kind: infer Kind extends keyof RegisteredGroupPaths;
+} ? Extract<RegisteredGroupPaths[Kind], P | `${P}@${string}`> : never;
+/** An entry at a group path. Its fields lay over the group's inherited ones, `override` and `extend`
+ *  alike, so neither takes a ref. */
+type PinGroupAdjustment<E> = {
+  override?: PartialGroupBodyOf<E>;
+  extend?: PartialGroupBodyOf<E>;
+  hidden?: boolean;
+};
 /** A ref to another entity of `E`'s kind, which re-points the path to it. */
 type KindRefOf<E> = E extends {
   readonly kind: infer K extends string;

package/dist/framework/defineConfig.d.ts

@@ -45,6 +45,9 @@ type ConfigKind<C> = C extends {
  */
 type Matched = any;
 type PartialBodyOf<E> = E extends Omit<EntityClass<infer F extends FieldsSchema, infer _G extends FieldsSchema, infer _K, Matched, Matched, Matched>, 'ref'> ? DeepPartial<CreateInput<F>> : never;
+/** One entity's group fields as a partial at every depth — what a delta against one of its group
+ *  nodes may say. */
+type PartialGroupBodyOf<E> = E extends Omit<EntityClass<infer _F extends FieldsSchema, infer G extends FieldsSchema, infer _K, Matched, Matched, Matched>, 'ref'> ? DeepPartial<CreateInput<G>> : never;
 /** Optional at every depth, stopping at refs, arrays and primitives. */
 type DeepPartial<T> = T extends Ref | readonly unknown[] ? T : T extends object ? { [K in keyof T]?: DeepPartial<T[K]> } : T;
 /**
@@ -196,4 +199,4 @@ declare function defineConfig<Owned extends EntityMap, Derived extends EntityMap
   extendsBase?: boolean;
 }): ConfigClass<Owned, Derived, Sources>;
 //#endregion
-export { Collection, ConfigClass, ConfigInstance, ConfigKind, EntityMap, OwnedRecords, PartialBodyOf, SourceMap, SourcesOf, defineConfig, kindsOf };
+export { Collection, ConfigClass, ConfigInstance, ConfigKind, EntityMap, OwnedRecords, PartialBodyOf, PartialGroupBodyOf, SourceMap, SourcesOf, defineConfig, kindsOf };