@cascateer/core 2.0.0

package/src/store.ts

@@ -0,0 +1,257 @@
+import { constant, Dictionary, mapValues, memoize, tap, thru } from "lodash";
+import {
+  identity,
+  merge,
+  mergeMap,
+  NextObserver,
+  Observable,
+  ReplaySubject,
+  shareReplay,
+  UnaryFunction,
+} from "rxjs";
+import { ExtendableDictionary } from "./lib";
+import { ComputedSignal, Signal } from "./observable";
+import {
+  flatMap,
+  MulticastAction,
+  MulticastSubject,
+  sequence,
+} from "./operators";
+import { Action, Transform } from "./types";
+
+export type StoreEffect<Result> = () => Signal<Result>;
+
+export type StoreEffects<Signals extends Dictionary<ComputedSignal<any>>> = {
+  [K in keyof Signals]: ReturnType<
+    <
+      Result extends Signals[K] extends ComputedSignal<infer Result>
+        ? Result
+        : never,
+    >() => StoreEffect<Result>
+  >;
+};
+
+export const asStoreEffects = <Signals extends Dictionary<ComputedSignal<any>>>(
+  signals: Signals,
+  observer?: NextObserver<Signal<any>>,
+): StoreEffects<Signals> =>
+  mapValues(signals, (signal) =>
+    memoize(() => tap(signal.capture(), (value) => observer?.next(value))),
+  );
+
+export class StoreAdapter<
+  Signals extends Dictionary<ComputedSignal<any>>,
+  Actions extends Dictionary<Action<any, any>>,
+> {
+  constructor(
+    public signals: Signals,
+    public actions: Actions,
+  ) {}
+}
+
+export class ExtendableStoreAdapter<
+  Signals extends Dictionary<ComputedSignal<any>>,
+  Actions extends Dictionary<Action<any, any>>,
+> {
+  complete(): StoreAdapter<Signals, Actions> {
+    return new StoreAdapter(
+      this.extendableSignals.complete(),
+      this.extendableActions.complete(),
+    );
+  }
+
+  constructor(
+    public context: {
+      transform: UnaryFunction<
+        Promise<string>,
+        {
+          share: UnaryFunction<
+            {
+              args: unknown;
+              callback: UnaryFunction<unknown, void>;
+              sameOrigin?: boolean;
+            },
+            void
+          >;
+          reflect: UnaryFunction<(args: any) => Promise<Transform<any>>, void>;
+        }
+      >;
+    },
+    private extendableSignals: ExtendableDictionary<
+      ComputedSignal<any>,
+      Signals
+    >,
+    private extendableActions: ExtendableDictionary<Action<any, any>, Actions>,
+  ) {}
+
+  provideSignals<MoreSignals extends Dictionary<ComputedSignal<any>>>(
+    signals: UnaryFunction<
+      {
+        signal: <T>(
+          constructor: UnaryFunction<Signals, ComputedSignal<T>>,
+        ) => ComputedSignal<T>;
+      },
+      MoreSignals
+    >,
+  ) {
+    return new ExtendableStoreAdapter(
+      this.context,
+      this.extendableSignals.extend(
+        (currentSignals) => () =>
+          signals({
+            signal: (constructor) => constructor(currentSignals),
+          }),
+      ),
+      this.extendableActions,
+    );
+  }
+
+  provideActions<MoreActions extends Dictionary<Action<any, any>>>(
+    actions: UnaryFunction<
+      {
+        action: <Args>(
+          constructor: UnaryFunction<
+            {
+              [K in keyof Signals]: {
+                update: <
+                  T extends Signals[K] extends ComputedSignal<infer T>
+                    ? T
+                    : never,
+                >(
+                  predicate: UnaryFunction<Args, Transform<T>>,
+                  config?: { sameOrigin?: boolean },
+                ) => Action<Args, any>;
+              };
+            },
+            Action<Args, any>
+          >,
+        ) => Action<Args, any>;
+      },
+      MoreActions
+    >,
+  ) {
+    return new ExtendableStoreAdapter(
+      this.context,
+      this.extendableSignals,
+      this.extendableActions.extend(
+        () =>
+          ({ property }) =>
+            actions({
+              action: (constructor) =>
+                property((key) =>
+                  constructor(
+                    mapValues(
+                      this.extendableSignals.currentValue,
+                      (signal) => ({
+                        update: (predicate, config = {}) =>
+                          thru(this.context.transform(key), (transform) => {
+                            transform.reflect((args) =>
+                              signal.reflector.reflect(predicate(args)),
+                            );
+
+                            return (args) =>
+                              new Promise<unknown>((callback) =>
+                                transform.share({ args, callback, ...config }),
+                              );
+                          }),
+                      }),
+                    ),
+                  ),
+                ),
+            }),
+      ),
+    );
+  }
+}
+
+export class StoreProvider<Data> extends ExtendableStoreAdapter<
+  { data: ComputedSignal<Data> },
+  {}
+> {
+  constructor({ actions }: { actions: MulticastSubject }) {
+    const transformActions = new ReplaySubject<
+      MulticastAction<Data, "transformAction">
+    >();
+    const seedActions: Observable<MulticastAction<Data, "seedAction">> =
+      actions.pipe(
+        flatMap((event) =>
+          event.type === "seedAction"
+            ? {
+                ...event,
+                predicate: constant(event.data.seed),
+              }
+            : [],
+        ),
+      );
+
+    const callbacks = new Map<string, UnaryFunction<unknown, void>>();
+
+    super(
+      {
+        transform: (key) => ({
+          share: ({ args, callback, sameOrigin }) =>
+            actions.next(
+              async ({ id }) => (
+                callbacks.set(id, callback),
+                {
+                  id,
+                  type: "transformAction",
+                  data: {
+                    key: await key,
+                    args,
+                  },
+                  sameOrigin,
+                }
+              ),
+            ),
+          reflect: (transform) =>
+            actions
+              .pipe(
+                mergeMap(async (event) => {
+                  if (
+                    event.type === "transformAction" &&
+                    event.data.key === (await key)
+                  ) {
+                    return transform(event.data.args).then((predicate) => ({
+                      ...event,
+                      predicate,
+                      callback: callbacks.get(event.id),
+                    }));
+                  }
+
+                  return [];
+                }),
+                flatMap(identity),
+              )
+              .subscribe(transformActions),
+        }),
+      },
+      new ExtendableDictionary({
+        data: new ComputedSignal({
+          value: merge(seedActions, transformActions).pipe(
+            sequence<MulticastAction<Data>, Data>(
+              ([action, previousAction], [previousState]) => {
+                if (action.type === "seedAction") {
+                  return action.predicate();
+                }
+
+                if (
+                  action.previousId !== previousAction?.id ||
+                  previousState == null
+                ) {
+                  throw new Error();
+                }
+
+                return tap(action.predicate(previousState), (state) =>
+                  action.callback?.call(null, state),
+                );
+              },
+            ),
+            shareReplay(1),
+          ),
+        }),
+      }),
+      new ExtendableDictionary({}),
+    );
+  }
+}

package/src/terminal.ts

@@ -0,0 +1,208 @@
+import { Dictionary, mapValues, memoize, tap, thru } from "lodash";
+import {
+  combineLatest,
+  distinct,
+  map,
+  NextObserver,
+  switchMap,
+  UnaryFunction,
+} from "rxjs";
+import { ApiAdapter, ApiEffect } from "./api";
+import { ExtendableDictionary } from "./lib";
+import { ComputedSignal, TapObservable } from "./observable";
+import { concat, transform } from "./operators";
+import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
+import { Action, Effect, TapEffect } from "./types";
+
+export interface TerminalEffect<Args, Result> extends TapEffect<Args, Result> {}
+
+type TerminalEffects<Effects extends Dictionary<TapEffect<any, any>>> = {
+  [K in keyof Effects]: ReturnType<
+    <
+      Args extends Effects[K] extends TapEffect<infer Args, infer _>
+        ? Args
+        : never,
+      Result extends Effects[K] extends TapEffect<infer _, infer Result>
+        ? Result
+        : never,
+    >() => TerminalEffect<Args, Result>
+  >;
+};
+
+const asTerminalEffects = <Effects extends Dictionary<TapEffect<any, any>>>(
+  effects: Effects,
+  observer?: NextObserver<TapObservable<any>>,
+): TerminalEffects<Effects> =>
+  mapValues(effects, (effect) =>
+    memoize((args) => tap(effect(args), (value) => observer?.next(value))),
+  );
+
+export class TerminalAdapter<
+  Effects extends Dictionary<TerminalEffect<any, any>>,
+  Actions extends Dictionary<Action<any, any>>,
+> {
+  constructor(
+    public effects: Effects,
+    public actions: Actions,
+  ) {}
+}
+
+export class ExtendableTerminalAdapter<
+  StoreSignals extends Dictionary<ComputedSignal<any>>,
+  StoreActions extends Dictionary<Action<any, any>>,
+  ApiEffects extends Dictionary<ApiEffect<any, any>>,
+  ApiActions extends Dictionary<Action<any, any>>,
+  Effects extends Dictionary<TerminalEffect<any, any>>,
+  Actions extends Dictionary<Action<any, any>>,
+> {
+  complete(): TerminalAdapter<Effects, Actions> {
+    return new TerminalAdapter(
+      this.extendableEffects.complete(),
+      this.extendableActions.complete(),
+    );
+  }
+
+  constructor(
+    private context: {
+      store: StoreAdapter<StoreSignals, StoreActions>;
+      api: ApiAdapter<ApiEffects, ApiActions>;
+    },
+    private extendableEffects: ExtendableDictionary<
+      TerminalEffect<any, any>,
+      Effects
+    >,
+    private extendableActions: ExtendableDictionary<Action<any, any>, Actions>,
+  ) {}
+
+  provideEffects<MoreEffects extends Dictionary<TerminalEffect<any, any>>>(
+    effects: UnaryFunction<
+      {
+        effect: <Args, Result>(
+          constructor: UnaryFunction<
+            {
+              store: {
+                effects: StoreEffects<StoreSignals>;
+              };
+              api: {
+                effects: TerminalEffects<ApiEffects>;
+              };
+              terminal: {
+                effects: TerminalEffects<Effects>;
+              };
+            },
+            Effect<Args, Result>
+          >,
+        ) => TerminalEffect<Args, Result>;
+      },
+      MoreEffects
+    >,
+  ) {
+    return new ExtendableTerminalAdapter(
+      this.context,
+      this.extendableEffects.extend(
+        (currentEffects) => () =>
+          effects({
+            effect: (constructor) => {
+              const deps = transform<TapObservable<any>, boolean>((deps) =>
+                deps.pipe(
+                  distinct(),
+                  concat(),
+                  switchMap((dep) =>
+                    combineLatest(dep.map((dep) => dep.loading)),
+                  ),
+                  map((values) => values.some(Boolean)),
+                ),
+              );
+
+              return thru(
+                constructor({
+                  store: {
+                    effects: asStoreEffects(this.context.store.signals, deps),
+                  },
+                  api: {
+                    effects: asTerminalEffects(this.context.api.effects, deps),
+                  },
+                  terminal: {
+                    effects: asTerminalEffects(currentEffects, deps),
+                  },
+                }),
+                (effect) => (args) => new TapObservable(effect(args), deps),
+              );
+            },
+          }),
+      ),
+      this.extendableActions,
+    );
+  }
+
+  provideActions<MoreActions extends Dictionary<Action<any, any>>>(
+    actions: UnaryFunction<
+      {
+        action: <Args, Result>(
+          constructor: UnaryFunction<
+            {
+              store: {
+                effects: StoreEffects<StoreSignals>;
+                actions: StoreActions;
+              };
+              api: {
+                actions: ApiActions;
+              };
+              terminal: {
+                effects: Effects;
+                actions: Actions;
+              };
+            },
+            Action<Args, Result>
+          >,
+        ) => Action<Args, Result>;
+      },
+      MoreActions
+    >,
+  ) {
+    return new ExtendableTerminalAdapter(
+      this.context,
+      this.extendableEffects,
+      this.extendableActions.extend(
+        (currentActions) => () =>
+          actions({
+            action: (constructor) =>
+              constructor({
+                store: {
+                  effects: asStoreEffects(this.context.store.signals),
+                  actions: this.context.store.actions,
+                },
+                api: {
+                  actions: this.context.api.actions,
+                },
+                terminal: {
+                  effects: this.extendableEffects.currentValue,
+                  actions: currentActions,
+                },
+              }),
+          }),
+      ),
+    );
+  }
+}
+
+export class TerminalProvider<
+  StoreSignals extends Dictionary<ComputedSignal<any>>,
+  StoreActions extends Dictionary<Action<any, any>>,
+  ApiEffects extends Dictionary<ApiEffect<any, any>>,
+  ApiActions extends Dictionary<Action<any, any>>,
+> extends ExtendableTerminalAdapter<
+  StoreSignals,
+  StoreActions,
+  ApiEffects,
+  ApiActions,
+  {},
+  {}
+> {
+  constructor(context: {
+    api: ApiAdapter<ApiEffects, ApiActions>;
+    store: StoreAdapter<StoreSignals, StoreActions>;
+  }) {
+    super(context, new ExtendableDictionary({}), new ExtendableDictionary({}));
+  }
+}

package/src/types.ts

@@ -0,0 +1,31 @@
+import { UnaryFunction } from "rxjs";
+import { Observable } from "rxjs/internal/Observable";
+import { ObservableInput } from "rxjs/internal/types";
+import { TapObservable } from "./observable";
+
+export interface Effect<Args, Result> extends UnaryFunction<
+  Args,
+  Observable<Result>
+> {}
+
+export interface TapEffect<Args, Result> extends UnaryFunction<
+  Args,
+  TapObservable<Result>
+> {}
+
+export interface Action<Args, Result> extends UnaryFunction<
+  Args,
+  Promise<Result>
+> {}
+
+export type MaybeArray<T> = T | T[];
+
+export type MaybeObservable<T> = T | Observable<T>;
+
+export type MaybeObservableInput<T> = T | ObservableInput<T>;
+
+export type MaybeObservableInputTuple<T> = {
+  [K in keyof T]: MaybeObservableInput<T[K]>;
+};
+
+export type Transform<T> = UnaryFunction<T, T>;

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "allowImportingTsExtensions": true,
+    "lib": ["ESNext", "DOM", "DOM.Iterable", "WebWorker"],
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "moduleResolution": "bundler",
+    "noEmit": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noUncheckedSideEffectImports": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "ES2022",
+    "types": ["vite/client"],
+    "useDefineForClassFields": true
+  },
+  "include": ["src"]
+}