World・読み取り

connect(options: {
  identity: Identity;
  access: RelayAccess | (() => Promise<RelayAccess>);
} & ({ discovery: string; endpoints?: never } | {
  endpoints: readonly string[]; discovery?: never;
})): Promise<Connection>;

World.create(options: {
  identity: Identity;
  name: string;
  source?: WorldData;
  storage?: Storage;
  blobs?: Storage;
}): Promise<World>;

World.open(source: WorldData | Storage, options: {
  identity: Identity;
  storage?: Storage;
  blobs?: Storage;
}): Promise<World>;

interface World {
  readonly id: string;
  readonly subject: string;
  readonly scopes: Scopes;
  readonly scenes: Scenes;
  readonly definitions: Definitions;
  readonly objects: Objects;
  readonly assets: Assets;
  readonly chat: Chat;
  readonly invitations: WorldInvitations;
  readonly keepers: Keepers;

  read(): DeepReadonly<ModelInfo>;
  read<K extends Collection>(query: ReadQuery<K>): ReadPage<Records[K]>;
  watch(listener: (info: DeepReadonly<ModelInfo>) => void, options?: WatchOptions): () => void;
  watch<K extends Collection>(query: ReadQuery<K>, listener: (page: ReadPage<Records[K]>) => void, options?: WatchOptions): () => void;
  availability(operation: DeepReadonly<WorldOperation>): Availability;
  rename(name: string): Promise<ChangeResult>;
  close(): Promise<void>;
}

interface DeepReadonlyArray<T> extends ReadonlyArray<DeepReadonly<T>> {}
type DeepReadonly<T> = T extends readonly unknown[]
  ? number extends T['length'] ? DeepReadonlyArray<T[number]> : { readonly [K in keyof T]: DeepReadonly<T[K]> }
  : T extends object ? { readonly [K in keyof T]: DeepReadonly<T[K]> } : T;

interface ModelInfo {
  name: string;
  owner: string;
  revision: number;
  rootScope: string;
  rootScene: string;
  writable: boolean;
  complete: boolean;
}

interface Records {
  scopes: Scope;
  scenes: Scene;
  definitions: Definition;
  objects: WorldObject;
  assets: Asset;
  messages: Message;
  keepers: KeeperRecord;
  invitations: InvitationRecord;
}
type Collection = keyof Records;

interface Bounds {
  left: number;
  top: number;
  right: number;
  bottom: number;
}

type ReadQuery<K extends Collection = Collection> = K extends Collection
  ? {
      from: K;
      id?: string;
      limit?: number;
      cursor?: string;
    } & (K extends 'objects'
      ? { scope?: string; scene?: string; bounds?: Bounds }
      : K extends 'scenes' | 'definitions' | 'assets' | 'messages'
        ? { scope?: string }
        : {})
  : never;

interface RelatedRecords {
  readonly scopes: Readonly<Record<string, DeepReadonly<Scope>>>;
  readonly scenes: Readonly<Record<string, DeepReadonly<Scene>>>;
  readonly definitions: Readonly<Record<string, DeepReadonly<Definition>>>;
  readonly assets: Readonly<Record<string, DeepReadonly<Asset>>>;
}

interface ReadPage<T> {
  readonly items: readonly DeepReadonly<T>[];
  readonly related: RelatedRecords;
  readonly total: number;
  readonly next: string | null;
  readonly revision: number;
}

type WorldOperation =
  | { operation: 'rename' | 'scopes.create' | 'save' | 'export' | 'merge' | 'close' }
  | { operation: 'scopes.remove' | 'scenes.configure' | 'scenes.remove'
      | 'objects.move' | 'objects.edit' | 'objects.remove'
      | 'assets.read' | 'assets.remove' | 'chat.remove' | 'invitations.revoke'; id: string }
  | { operation: 'scenes.create' | 'assets.import' | 'chat.send'; scope: string }
  | { operation: 'definitions.set'; scope: string; id?: string }
  | { operation: 'objects.place'; definition: string; placement: Placement }
  | { operation: 'invitations.create'; actions: WorldGrant['actions'] }
  | { operation: 'keepers.appoint'; subject: string };

type Availability =
  | { allowed: true; reason: null }
  | { allowed: false; reason:
      'closed' | 'missing' | 'forbidden' | 'connecting'
      | 'writer-absent' | 'incomplete' | 'in-use' };

const moving = world.availability({ operation: 'objects.move', id: objectId });
const placing = world.availability({ operation: 'objects.place', definition: definitionId, placement });

interface ChangeResult {
  revision: number;
  accepted: 'local' | 'shared';
}
type Created = ChangeResult & { id: string };