@raphy-js/raph 1.0.0-dev.2 → 1.0.1-dev.25

package/dist/api/types.d.ts

@@ -1,25 +1,170 @@
 import { RaphKernel } from '../path/RaphKernel';
-import { RaphPhase, RaphSchedulerMode } from '../runtime/phase.types';
-export type RaphMode = 'reactivity' | 'runtime';
-export interface RaphReactivityConfigureOptions {
-    readonly mode: 'reactivity';
+import { RaphReactivity } from '../reactivity/engine';
+import { ScopeNode } from '../reactivity/scope';
+import { Disposer } from '../reactivity/types';
+import { RaphNode } from '../runtime/ownership/RaphNode';
+import { RaphScope } from '../runtime/ownership/RaphScope';
+import { RaphAggregateSource, RaphEffectOptions, RaphPhase, RaphPhaseEffect, RaphWatchOptions, RaphWatchSource } from '../runtime/phases/phase.types';
+import { RaphRuntime, RaphRuntimeOptions } from '../runtime/RaphRuntime';
+import { RaphAggregate } from '../runtime/reactivity/RaphWorkGraph';
+import { RaphReactivityInstance } from './RaphReactivityInstance';
+export interface RaphReactiveApi {
+    readonly signal: RaphReactivity['signal'];
+    readonly reactive: RaphReactivity['reactive'];
+    readonly computed: RaphReactivity['computed'];
+    readonly batch: RaphReactivity['batch'];
+    readonly untracked: RaphReactivity['untracked'];
 }
-export interface RaphRuntimeDefaults {
-    readonly scheduler?: RaphSchedulerMode;
-    readonly enforceActions?: boolean;
+export interface RaphReactivityApi extends RaphReactiveApi {
+    readonly effect: RaphReactivity['effect'];
+    readonly watch: RaphReactivity['watch'];
+    readonly scope: () => ScopeNode;
 }
-export interface RaphRuntimeConfigureOptions extends RaphRuntimeDefaults {
-    readonly mode: 'runtime';
-    readonly createDefaultRuntime?: true;
-    readonly defaultRuntimeId?: string;
-    readonly kernel?: RaphKernel;
-    readonly phases?: readonly RaphPhase[];
+interface RaphFacadeAction {
+    <Args extends unknown[], Result>(operation: (...args: Args) => Result): (...args: Args) => Result;
+    <Args extends unknown[], Result>(name: string, operation: (...args: Args) => Result): (...args: Args) => Result;
 }
-export interface RaphRuntimeRegistryConfigureOptions extends RaphRuntimeDefaults {
+export interface RaphRuntimeApi extends RaphReactiveApi {
+    readonly acquireLoop: RaphRuntime['acquireLoop'];
+    readonly action: RaphFacadeAction;
+    readonly addPhase: RaphRuntime['addPhase'];
+    readonly afterFlush: RaphRuntime['afterFlush'];
+    readonly aggregate: (sources: readonly RaphAggregateSource[]) => RaphAggregate;
+    readonly clearPhases: RaphRuntime['clearPhases'];
+    readonly debug: RaphRuntime['debug'];
+    readonly definePhases: RaphRuntime['definePhases'];
+    readonly delete: RaphRuntime['delete'];
+    readonly derive: RaphRuntime['derive'];
+    readonly effect: (phase: string, callback: RaphPhaseEffect, options?: RaphEffectOptions) => Disposer;
+    readonly flush: RaphRuntime['flush'];
+    readonly frame: RaphRuntime['frame'];
+    readonly frameTick: RaphRuntime['frameTick'];
+    readonly get: RaphRuntime['get'];
+    readonly getDerivedSnapshot: RaphRuntime['getDerivedSnapshot'];
+    readonly getNode: RaphRuntime['getNode'];
+    readonly has: RaphRuntime['has'];
+    readonly kernel: RaphKernel;
+    readonly loopEnabled: boolean;
+    readonly merge: RaphRuntime['merge'];
+    readonly meta: RaphRuntime['meta'];
+    readonly node: RaphRuntime['node'];
+    readonly path: RaphRuntime['path'];
+    readonly peek: RaphRuntime['peek'];
+    readonly phases: RaphRuntime['phases'];
+    readonly requestExecution: RaphRuntime['requestExecution'];
+    readonly root: RaphNode;
+    readonly rootScope: RaphScope;
+    readonly scope: (id: string) => RaphScope;
+    readonly set: RaphRuntime['set'];
+    readonly startLoop: RaphRuntime['startLoop'];
+    readonly stopLoop: RaphRuntime['stopLoop'];
+    readonly watch: (source: RaphWatchSource, phase: string, callback: RaphPhaseEffect, options?: RaphWatchOptions) => Disposer;
+}
+export type RaphInstance = RaphRuntime | RaphReactivityInstance;
+export type RaphInstanceMode = 'reactivity' | 'runtime';
+export interface RaphReactivityInstanceOptions {
+    readonly adaptiveDependencyIndex?: boolean;
+    readonly id?: string;
+}
+export type RaphRuntimeConfigureOptions = Omit<RaphRuntimeOptions, 'id'> & {
+    readonly default?: never;
+    readonly id?: string;
+    readonly instances?: never;
+    readonly mode?: 'runtime';
+    readonly phases?: readonly RaphPhase[];
+};
+export type RaphReactivityConfigureOptions = Omit<RaphReactivityInstanceOptions, 'id'> & {
+    readonly default?: never;
+    readonly id?: string;
+    readonly instances?: never;
+    readonly mode: 'reactivity';
+};
+export type RaphFlatConfigureOptions = RaphReactivityConfigureOptions | RaphRuntimeConfigureOptions;
+export type RaphRuntimeInstanceDefinition = Omit<RaphRuntimeOptions, 'id'> & {
+    readonly default?: boolean;
+    readonly id?: string;
     readonly mode: 'runtime';
-    readonly createDefaultRuntime: false;
-    readonly defaultRuntimeId?: never;
+    readonly phases?: readonly RaphPhase[];
+};
+export type RaphReactivityInstanceDefinition = Omit<RaphReactivityInstanceOptions, 'id'> & {
+    readonly default?: boolean;
+    readonly id?: string;
+    readonly mode: 'reactivity';
+};
+export type RaphInstanceDefinition = RaphReactivityInstanceDefinition | RaphRuntimeInstanceDefinition;
+export type RaphInstanceDefinitions = Readonly<Record<string, RaphInstanceDefinition>>;
+export interface RaphInstancesConfigureOptions<Definitions extends RaphInstanceDefinitions = RaphInstanceDefinitions> {
+    readonly adaptiveDependencyIndex?: never;
+    readonly default?: never;
+    readonly enforceActions?: never;
+    readonly id?: never;
+    readonly instances: Definitions;
     readonly kernel?: never;
+    readonly mode?: never;
     readonly phases?: never;
+    readonly scheduler?: never;
+}
+export type RaphConfigureOptions = RaphFlatConfigureOptions | RaphInstancesConfigureOptions;
+type InvalidInstanceDefinitionKeys<Definitions extends RaphInstanceDefinitions> = {
+    [Key in keyof Definitions]: Exclude<keyof Definitions[Key], Definitions[Key] extends {
+        readonly mode: 'reactivity';
+    } ? keyof RaphReactivityInstanceDefinition : keyof RaphRuntimeInstanceDefinition>;
+}[keyof Definitions];
+type StrictInstancesConfigureOptions<Options, Definitions extends RaphInstanceDefinitions> = Exclude<keyof Options, keyof RaphInstancesConfigureOptions> extends never ? InvalidInstanceDefinitionKeys<Definitions> extends never ? Options : never : never;
+export type StrictRaphConfigureOptions<Options extends RaphConfigureOptions> = Options extends {
+    readonly instances: infer Definitions extends RaphInstanceDefinitions;
+} ? StrictInstancesConfigureOptions<Options, Definitions> : Options extends {
+    readonly mode: 'reactivity';
+} ? Options & Record<Exclude<keyof Options, keyof RaphReactivityConfigureOptions>, never> : Options & Record<Exclude<keyof Options, keyof RaphRuntimeConfigureOptions>, never>;
+type DefinitionInstance<Definition> = Definition extends {
+    readonly mode: 'reactivity';
+} ? RaphReactivityInstance : RaphRuntime;
+type ResolvedDefinitionId<Key, Definition> = Definition extends {
+    readonly id: infer Id extends string;
+} ? Id : Key extends string ? Key : never;
+type InstancesFromDefinitions<Definitions extends RaphInstanceDefinitions> = {
+    [Key in keyof Definitions as ResolvedDefinitionId<Key, Definitions[Key]>]: DefinitionInstance<Definitions[Key]>;
+};
+export type RaphInstanceMapForConfigure<Options extends RaphConfigureOptions> = Options extends {
+    readonly instances: infer Definitions extends RaphInstanceDefinitions;
+} ? InstancesFromDefinitions<Definitions> : Options extends RaphFlatConfigureOptions ? Record<Options extends {
+    readonly id: infer Id extends string;
+} ? Id : 'default', DefinitionInstance<Options>> : never;
+type DefaultFromDefinitions<Definitions extends RaphInstanceDefinitions> = {
+    [Key in keyof Definitions]: Definitions[Key] extends {
+        readonly default: true;
+    } ? DefinitionInstance<Definitions[Key]> : never;
+}[keyof Definitions];
+export type RaphDefaultInstanceForConfigure<Options extends RaphConfigureOptions> = Options extends {
+    readonly instances: infer Definitions extends RaphInstanceDefinitions;
+} ? DefaultFromDefinitions<Definitions> : Options extends RaphFlatConfigureOptions ? DefinitionInstance<Options> : never;
+type RuntimeIds<Instances extends Record<string, RaphInstance>> = {
+    [Id in keyof Instances]: Instances[Id] extends RaphRuntime ? Id : never;
+}[keyof Instances] & string;
+type ReactivityIds<Instances extends Record<string, RaphInstance>> = {
+    [Id in keyof Instances]: Instances[Id] extends RaphReactivityInstance ? Id : never;
+}[keyof Instances] & string;
+export interface ConfiguredRaphRegistry<Instances extends Record<string, RaphInstance>> {
+    readonly configured: true;
+    readonly defaultInstanceId: keyof Instances & string | undefined;
+    createReactivity: (options?: RaphReactivityInstanceOptions) => RaphReactivityInstance;
+    createKernel: (options?: ConstructorParameters<typeof import('../path/RaphKernel').RaphKernel>[0]) => RaphKernel;
+    createRuntime: (options?: RaphRuntimeOptions) => RaphRuntime;
+    disposeInstance: <Id extends keyof Instances & string>(id: Id) => boolean;
+    getInstance: <Id extends keyof Instances & string>(id: Id) => Instances[Id] | undefined;
+    hasInstance: <Id extends keyof Instances & string>(id: Id) => boolean;
+    instance: <Id extends keyof Instances & string>(id: Id) => Instances[Id];
+    reactivity: <Id extends ReactivityIds<Instances>>(id: Id) => Extract<Instances[Id], RaphReactivityInstance>;
+    runtime: <Id extends RuntimeIds<Instances>>(id: Id) => Extract<Instances[Id], RaphRuntime>;
 }
-export type RaphConfigureOptions = RaphReactivityConfigureOptions | RaphRuntimeConfigureOptions | RaphRuntimeRegistryConfigureOptions;
+type RuntimeDefaultFacadeApi<DefaultInstance extends RaphRuntime> = RaphRuntimeApi & {
+    instance: () => DefaultInstance;
+    runtime: () => DefaultInstance;
+};
+type ReactivityDefaultFacadeApi<DefaultInstance extends RaphReactivityInstance> = RaphReactivityApi & {
+    instance: () => DefaultInstance;
+    reactivity: () => DefaultInstance;
+};
+type DefaultFacadeApi<DefaultInstance extends RaphInstance> = [DefaultInstance] extends [never] ? object : DefaultInstance extends RaphRuntime ? RuntimeDefaultFacadeApi<DefaultInstance> : DefaultInstance extends RaphReactivityInstance ? ReactivityDefaultFacadeApi<DefaultInstance> : object;
+export type ConfiguredRaph<Options extends RaphConfigureOptions> = ConfiguredRaphRegistry<RaphInstanceMapForConfigure<Options>> & DefaultFacadeApi<RaphDefaultInstanceForConfigure<Options>>;
+export {};