@adobe/ecs 0.2.0 → 0.2.1

package/src/interface/trait/trait.type-test.ts

@@ -16,7 +16,7 @@ const gpuOnly = Symbol("traitTest/gpuOnly");
 const nonPersistent = Symbol("traitTest/nonPersistent");
 declare module '@adobe/ecs' {
     export interface Traits<N> {
-        readonly [gpuOnly]: N extends Component.Key ? (IsStruct<Component.Value<N>> extends true ? true : never) : never;
+        readonly [gpuOnly]: N extends Component.Key ? (IsStruct<Component<N>> extends true ? true : never) : never;
         readonly [nonPersistent]: N extends Component.Key ? (Components[N] extends { readonly derived: true } ? never : true) : true;
     }
 }
@@ -53,15 +53,15 @@ declare module '@adobe/ecs' {
 
 // Types filter components by their traits and value types.
 type Ours = typeof parent | typeof follows | typeof slot | typeof ready | typeof score | typeof link | typeof pair | typeof cache;
-check<Equal<Component.Value<typeof parent>, Entity>>();
-check<Equal<Component.Value<typeof link>, { readonly to: Entity; readonly weight: number }>>();
+check<Equal<Component<typeof parent>, Entity>>();
+check<Equal<Component<typeof link>, { readonly to: Entity; readonly weight: number }>>();
 check<Equal<Extract<Component.With<"reference">, Ours>, typeof parent | typeof follows>>();
 check<Equal<Extract<Component.With<"reference", "owner">, Ours>, typeof parent>>();
 check<Equal<Extract<Derived, Ours>, typeof slot>>();
 check<Equal<Extract<Component.With<typeof gpuOnly>, Ours>, typeof pair>>();
 type Persisted = Exclude<Essential, Component.With<typeof nonPersistent>>;
 check<Equal<Extract<Persisted, Ours>, Exclude<Ours, typeof slot | typeof cache>>>();
-check<Equal<Resource.Value<typeof time>, number>>();
+check<Equal<Resource<typeof time>, number>>();
 
 // Commands add and remove only essential components.
 export const issue = (commands: Commands, entity: Entity): void => {

package/src/interface/trait/types.ts

@@ -9,7 +9,7 @@ import type { IsComparable, IsString, IsStruct } from '../schema/is-struct.js';
 import type { Thread } from '../thread/thread.js';
 
 /** The value type of the component or resource `N`. */
-type ValueOf<N> = N extends Component.Key ? Component.Value<N> : N extends Resource.Key ? Resource.Value<N> : never;
+type ValueOf<N> = N extends Component.Key ? Component<N> : N extends Resource.Key ? Resource<N> : never;
 
 /**
  * Whether each component's and resource's value is a struct, `"string"` for a string, computed once so a check is a
@@ -39,14 +39,14 @@ export interface Traits<N extends Component.Key | Resource.Key> {
      * component. Not on a derived component, whose target only a command could set.
      */
     readonly reference: N extends Component.Key
-        ? Components[N] extends { readonly derived: true } | { readonly shared: true } ? never : [Component.Value<N>] extends [Entity] ? "owner" | "weak" : never
+        ? Components[N] extends { readonly derived: true } | { readonly shared: true } ? never : [Component<N>] extends [Entity] ? "owner" | "weak" : never
         : never;
     /**
      * On a resource, the operator systems reduce into it with: each run that a contributor runs in starts it at the
      * operator's identity and leaves it holding the fold of every contribution. Booleans fold bitwise.
      */
     readonly reduce: N extends Resource.Key
-        ? [Resource.Value<N>] extends [boolean] ? "&" | "|" | "^" : Structs[N] extends true ? Reduction : never
+        ? [Resource<N>] extends [boolean] ? "&" | "|" | "^" : Structs[N] extends true ? Reduction : never
         : never;
     /**
      * The logical thread an object lives on, `"world"` without it. Not on a struct or a string, which live in shared
@@ -64,6 +64,6 @@ export interface Traits<N extends Component.Key | Resource.Key> {
      * reference, and it has no thread: every thread reads it.
      */
     readonly shared: N extends Component.Key
-        ? Components[N] extends { readonly derived: true } | { readonly reference: unknown } ? never : IsComparable<Component.Value<N>> extends true ? true : never
+        ? Components[N] extends { readonly derived: true } | { readonly reference: unknown } ? never : IsComparable<Component<N>> extends true ? true : never
         : never;
 }

package/src/interface/world/create.ts

@@ -5,15 +5,11 @@ import type { InvalidDeclarations } from './declarations.js';
 import type { World } from './world.js';
 
 /** Values resources start at in place of their defaults: any but those only the world writes. */
-export type InitialResources = { readonly [K in Exclude<Resource.Key, WorldWritten>]?: Resource.Value<K> };
+export type InitialResources = { readonly [K in Exclude<Resource.Key, WorldWritten>]?: Resource<K> };
 
 /**
- * Creates a world on this thread, synchronously, with resources starting at the given values in place of their
- * defaults. This thread is its `"world"` thread for the world's life: it runs the sync points, the ticks and the GPU
- * device, and fills every logical thread no joined thread claims. Keys are the resources' symbols, built-in ones
- * included (`{ [workers]: 0 }`); string keys are never a resource's, so they're ignored. Throws for a symbol that isn't
- * a resource, or is one only the world writes. While a declaration's trait or default doesn't hold, each call fails to
- * compile, once, naming each such key, its members and what's wrong with them.
+ * The type of `World.create`.
+ * @inline
  */
 export type Create = (
     // Unknown while every declaration holds; else what a call's `this` can't be, so the call reports it, printed whole.

package/src/interface/world/declarations.ts

@@ -30,5 +30,5 @@ type Reported<K, Members extends PropertyKey> = [Members] extends [never] ? neve
  * `World.create` reports these.
  */
 export type InvalidDeclarations =
-    | { readonly [K in Component.Key]: Reported<K, Invalid<K, Components[K], Component.Value<K>>> }[Component.Key]
-    | { readonly [K in Resource.Key]: Reported<K, Invalid<K, Resources[K], Resource.Value<K>>> }[Resource.Key];
+    | { readonly [K in Component.Key]: Reported<K, Invalid<K, Components[K], Component<K>>> }[Component.Key]
+    | { readonly [K in Resource.Key]: Reported<K, Invalid<K, Resources[K], Resource<K>>> }[Resource.Key];

package/src/interface/world/join.ts

@@ -3,15 +3,7 @@ import type { Thread } from '../thread/thread.js';
 import type { World } from './world.js';
 
 /**
- * Joins, from another thread, a world that `share` let join through the other end of `port`, claiming the logical
- * `threads` this thread fills: their objects live here, and the systems and finalizers reading them run here. Resolves,
- * once the world accepted the claim, to the same world: its `run` runs systems there, and its `add` and `remove` take
- * observer systems, which run here after the world's sync points. Add them before awaiting anything else, so the
- * world's `share` resolves with them in place. Its `dispose` disconnects this thread. Rejects with an `Error` saying
- * why it didn't join: the world refused the claim, was disposed, or its thread ended first, as the platform reports it:
- * the world's `Worker` failing to start or throwing first, a port closed, as in node, or, in a browser, the world's
- * thread ending once it was shared through a port this thread listened on. A browser world's worker that the page ended
- * before this thread heard from it isn't reported, so the join stays pending. Rejects too where memory can't be shared,
- * as without cross-origin isolation.
+ * The type of `World.join`.
+ * @inline
  */
 export type Join = (port: Parameters<World["share"]>[0], options?: { readonly threads?: readonly Exclude<Thread, "world">[] }) => Promise<World>;

package/src/interface/world/loop.type-test.ts

@@ -25,14 +25,14 @@ world.remove(move);
 void removed;
 
 // Built-in resources.
-check<Equal<Resource.Value<typeof gpuDevice>, GPUDevice | null>>();
-check<Equal<Resource.Value<typeof workers>, number | null>>();
+check<Equal<Resource<typeof gpuDevice>, GPUDevice | null>>();
+check<Equal<Resource<typeof workers>, number | null>>();
 // null is the platform's choice of pool size.
 export const platformPool: World = create({ [workers]: null });
-check<Equal<Resource.Value<typeof always>, boolean>>();
-check<Equal<Resource.Value<typeof wake>, number>>();
-check<Equal<Resource.Value<typeof clock>, { readonly now: number; readonly delta: number; readonly tick: number }>>();
-check<Equal<Resource.Value<typeof cadence>, { readonly kind: "frame" } | { readonly kind: "fixed"; readonly step: number; readonly maxSteps?: number }>>();
+check<Equal<Resource<typeof always>, boolean>>();
+check<Equal<Resource<typeof wake>, number>>();
+check<Equal<Resource<typeof clock>, { readonly now: number; readonly delta: number; readonly tick: number }>>();
+check<Equal<Resource<typeof cadence>, { readonly kind: "frame" } | { readonly kind: "fixed"; readonly step: number; readonly maxSteps?: number }>>();
 // Built-in resources are symbols, so worlds start them at other values through their imported keys.
 check<Equal<[typeof gpuDevice, typeof workers, typeof cadence, typeof always, typeof wake, typeof clock] extends readonly symbol[] ? true : false, true>>();
 // @ts-expect-error a resource key is its imported symbol, never its description

package/src/observe/members.ts

@@ -5,7 +5,7 @@ import type { Observe } from './observe.js';
 import { observeCount, observeSelect } from './select.js';
 import type { Query } from './query.js';
 import { observeResource } from './resource.js';
-import type { ReadonlyResourceValue, ReadonlyValue } from './values.js';
+import type { ReadonlyResourceType, ReadonlyType } from './values.js';
 
 export { toPromise } from './to-promise.js';
 export type { Query } from './query.js';
@@ -14,7 +14,7 @@ export type { Query } from './query.js';
  * A resource's value, then a new one after each run or tick that changed it: one whose sync point stamped it, even with
  * the same value, a reduced resource when its fold differs.
  */
-export const resource = <R extends Resource.Key>(world: World, resource: R): Observe<ReadonlyResourceValue<R>> =>
+export const resource = <R extends Resource.Key>(world: World, resource: R): Observe<ReadonlyResourceType<R>> =>
     observeResource(world, resource);
 
 /**
@@ -27,7 +27,7 @@ export const entity = <const R extends readonly Component.Key[] = [], const O ex
     world: World,
     entity: Entity,
     components: { readonly required?: R; readonly optional?: O },
-): Observe<({ readonly [K in keyof Pick<Components, R[number]>]: ReadonlyValue<K> } & { readonly [K in keyof Pick<Components, O[number]>]?: ReadonlyValue<K> }) | null> =>
+): Observe<({ readonly [K in keyof Pick<Components, R[number]>]: ReadonlyType<K> } & { readonly [K in keyof Pick<Components, O[number]>]?: ReadonlyType<K> }) | null> =>
     observeEntity(world, entity, components);
 
 /**

package/src/observe/query.ts

@@ -10,7 +10,7 @@ type Comparison<T> = {
     readonly ">="?: T;
 };
 
-type ValuesOf<C extends readonly Component.Key[]> = { readonly [K in C[number]]: Component.Value<K> };
+type ValuesOf<C extends readonly Component.Key[]> = { readonly [K in C[number]]: Component<K> };
 
 /**
  * Entities that have every component in `required`, every entity but the resource entity without it, and none in

package/src/observe/select.ts

@@ -161,7 +161,7 @@ const rangeOf = (condition: unknown): Range => {
     return bounds.length === 0 ? unbounded : { range, bounds, exact };
 };
 
-type Value = Component.Value<Component.Key>;
+type Value = Component<Component.Key>;
 
 /** A value or comparison a sorted index on one key part looks up by. */
 type Bound = Value | { readonly "<="?: Value; readonly ">="?: Value; readonly "=="?: Value };

package/src/observe/values.ts

@@ -4,7 +4,7 @@ import type { Component, Resource } from '../interface/index.js';
 type Primitive = string | number | boolean | bigint | symbol | null | undefined;
 
 /** Component `K`'s value as observers give it: read-only, with branded primitives such as `Entity` as they are. */
-export type ReadonlyValue<K extends Component.Key> = Component.Value<K> extends Primitive ? Component.Value<K> : Readonly<Component.Value<K>>;
+export type ReadonlyType<K extends Component.Key> = Component<K> extends Primitive ? Component<K> : Readonly<Component<K>>;
 
 /** Resource `K`'s value as observers give it. */
-export type ReadonlyResourceValue<K extends Resource.Key> = Resource.Value<K> extends Primitive ? Resource.Value<K> : Readonly<Resource.Value<K>>;
+export type ReadonlyResourceType<K extends Resource.Key> = Resource<K> extends Primitive ? Resource<K> : Readonly<Resource<K>>;