@cascateer/core 2.0.0

package/src/observable/index.ts

@@ -0,0 +1,4 @@
+export { Future } from "./Future";
+export { ComputedSignal, Signal } from "./Signal";
+export { TapObservable } from "./TapObservable";
+export { TransformSubject } from "./TransformSubject";

package/src/operators/concat.ts

@@ -0,0 +1,6 @@
+import { OperatorFunction, scan } from "rxjs";
+
+export const concat =
+  <T>(): OperatorFunction<T | T[], T[]> =>
+  (source) =>
+    source.pipe(scan((acc, curr) => acc.concat(curr), new Array<T>()));

package/src/operators/exchangeWith.ts

@@ -0,0 +1,23 @@
+import { fromEvent, map, Observable, OperatorFunction } from "rxjs";
+import { property } from "../lib";
+
+export const exchangeWith =
+  <InMessage, OutMessage>(
+    port: MessagePort,
+  ): OperatorFunction<OutMessage, InMessage> =>
+  (messages) =>
+    new Observable<InMessage>((subscriber) => {
+      fromEvent<MessageEvent<any>>(port, "message")
+        .pipe(map(property("data")))
+        .subscribe(subscriber);
+
+      port.start();
+
+      subscriber.add({
+        unsubscribe: () => port.close(),
+      });
+
+      return messages.subscribe({
+        next: (message) => port.postMessage(message),
+      });
+    });

package/src/operators/flatMap.ts

@@ -0,0 +1,11 @@
+import { OperatorFunction, from, map, mergeMap } from "rxjs";
+
+export const flatMap =
+  <T, U>(
+    project: (value: T, index: number) => U | U[],
+  ): OperatorFunction<T, U> =>
+  (source) =>
+    source.pipe(
+      map(project),
+      mergeMap((value) => from(Array.isArray(value) ? value : [value])),
+    );

package/src/operators/index.ts

@@ -0,0 +1,15 @@
+export { concat } from "./concat";
+export { exchangeWith } from "./exchangeWith";
+export { flatMap } from "./flatMap";
+export {
+  multicast,
+  type MulticastAction,
+  type MulticastActionMessage,
+  type MulticastClientMessage,
+  type MulticastConnectMessageData,
+  type MulticastHostMessage,
+  type MulticastSubject,
+} from "./multicast";
+export { sequence } from "./sequence";
+export { tapSubscription } from "./tapSubscription";
+export { transform } from "./transform";

package/src/operators/multicast.ts

@@ -0,0 +1,99 @@
+import { concatMap, shareReplay, startWith, UnaryFunction } from "rxjs";
+import { v4 } from "uuid";
+import SharedWorker from "../multicast?sharedworker";
+import { ComputedSignal, TransformSubject } from "../observable";
+import { exchangeWith, transform } from "../operators";
+import { Transform } from "../types";
+
+interface MulticastBaseMessage<Type, Data> {
+  id: string;
+  previousId?: string;
+  type: Type;
+  data: Data;
+  sameOrigin?: boolean;
+  origin?: MessagePort;
+}
+
+interface MulticastActions<Data> {
+  seedAction: {
+    predicate: () => Data;
+    data: {
+      seed: Data;
+    };
+  };
+  transformAction: {
+    predicate: Transform<Data>;
+    data: {
+      key: string;
+      args: unknown;
+    };
+  };
+}
+
+type MulticastBaseActionMessage<
+  Data,
+  Type extends keyof MulticastActions<Data>,
+> = MulticastBaseMessage<Type, MulticastActions<Data>[Type]["data"]>;
+
+export type MulticastActionMessage<Data> =
+  | MulticastBaseActionMessage<Data, "seedAction">
+  | MulticastBaseActionMessage<Data, "transformAction">;
+
+export type MulticastAction<
+  Data,
+  Type extends keyof MulticastActions<Data> = keyof MulticastActions<Data>,
+> = MulticastActionMessage<Data> &
+  {
+    [T in Type]: {
+      type: T;
+      target?: ComputedSignal<Data>;
+      predicate: MulticastActions<Data>[T]["predicate"];
+      callback?: UnaryFunction<Data, void>;
+    };
+  }[Type];
+
+export interface MulticastConnectMessageData<Seed> {
+  key: string;
+  seed: Seed;
+}
+
+type MulticastConnectMessage<Seed = any> = MulticastBaseMessage<
+  "connect",
+  MulticastConnectMessageData<Seed>
+>;
+
+export type MulticastHostMessage = MulticastActionMessage<any>;
+export type MulticastClientMessage =
+  | MulticastActionMessage<any>
+  | MulticastConnectMessage;
+
+type MulticastMessage = MulticastHostMessage | MulticastClientMessage;
+
+type MulticastMessageConstructor<Message extends MulticastMessage> =
+  UnaryFunction<Record<"key" | "id", string>, Promise<Message>>;
+
+export interface MulticastSubject extends TransformSubject<
+  MulticastMessageConstructor<MulticastClientMessage>,
+  MulticastHostMessage
+> {}
+
+export const multicast = <Seed>(
+  key: Promise<string>,
+  seed: Seed,
+): MulticastSubject =>
+  transform((messages) =>
+    messages.pipe(
+      startWith(
+        ({ key, id }): MulticastConnectMessage => ({
+          id,
+          type: "connect",
+          data: { key, seed },
+        }),
+      ),
+      concatMap((message) => key.then((key) => message({ key, id: v4() }))),
+      exchangeWith<MulticastHostMessage, MulticastClientMessage>(
+        new SharedWorker().port,
+      ),
+      shareReplay({ refCount: false }),
+    ),
+  );

package/src/operators/sequence.ts

@@ -0,0 +1,23 @@
+import { map, OperatorFunction, scan } from "rxjs";
+
+export const sequence =
+  <Input, Output>(
+    predicate: (inputs: [Input, ...Input[]], outputs: Output[]) => Output,
+  ): OperatorFunction<Input, Output> =>
+  (source) =>
+    source.pipe(
+      scan(
+        ({ inputs, outputs }, input) => ({
+          inputs: [input],
+          outputs: [predicate([input, ...inputs], outputs)],
+        }),
+        { inputs: new Array<Input>(), outputs: new Array<Output>() },
+      ),
+      map(({ outputs }) => {
+        if (!(0 in outputs)) {
+          throw new Error();
+        }
+
+        return outputs[0];
+      }),
+    );

package/src/operators/tapSubscription.ts

@@ -0,0 +1,11 @@
+import { MonoTypeOperatorFunction, NextObserver, tap } from "rxjs";
+
+export const tapSubscription =
+  <T>(observer?: NextObserver<boolean>): MonoTypeOperatorFunction<T> =>
+  (source) =>
+    source.pipe(
+      tap({
+        subscribe: () => observer?.next(true),
+        unsubscribe: () => observer?.next(false),
+      }),
+    );

package/src/operators/transform.ts

@@ -0,0 +1,7 @@
+import { Observable, Subject, UnaryFunction } from "rxjs";
+import { TransformSubject } from "../observable";
+
+export const transform = <T, U = T>(
+  project: UnaryFunction<Subject<T>, Observable<U>>,
+  target?: Subject<T>,
+) => new TransformSubject(project, target);

package/src/slice.ts

@@ -0,0 +1,274 @@
+import { Dictionary, mapValues } from "lodash";
+import { defer, map, share, UnaryFunction } from "rxjs";
+import { createFragment } from ".";
+import { ApiAdapter, ApiEffect } from "./api";
+import {
+  ComponentConstructor,
+  ComponentsAdapter,
+  ComponentsProvider,
+} from "./component";
+import { defineCustomElement } from "./dom";
+import { ExtendableDictionary } from "./lib";
+import { ComputedSignal } from "./observable";
+import { multicast, MulticastSubject } from "./operators";
+import { StoreAdapter, StoreProvider } from "./store";
+import { TerminalAdapter, TerminalEffect, TerminalProvider } from "./terminal";
+import { Action } from "./types";
+
+interface SliceConfig<
+  Data,
+  StoreSignals extends Dictionary<ComputedSignal<any>>,
+  StoreActions extends Dictionary<Action<any, any>>,
+  ApiEffects extends Dictionary<ApiEffect<any, any>>,
+  ApiActions extends Dictionary<Action<any, any>>,
+  TerminalEffects extends Dictionary<TerminalEffect<any, any>>,
+  TerminalActions extends Dictionary<Action<any, any>>,
+  Components extends Dictionary<ComponentConstructor<any>>,
+> {
+  data: Data;
+  store: UnaryFunction<
+    {
+      StoreProvider: {
+        new (): StoreProvider<Data>;
+      };
+    },
+    StoreAdapter<StoreSignals, StoreActions>
+  >;
+  api: ApiAdapter<ApiEffects, ApiActions>;
+  terminal: UnaryFunction<
+    {
+      TerminalProvider: {
+        new (): TerminalProvider<
+          StoreSignals,
+          StoreActions,
+          ApiEffects,
+          ApiActions
+        >;
+      };
+    },
+    TerminalAdapter<TerminalEffects, TerminalActions>
+  >;
+  components: UnaryFunction<
+    {
+      ComponentsProvider: {
+        new (): ComponentsProvider<
+          StoreSignals,
+          StoreActions,
+          TerminalEffects,
+          TerminalActions
+        >;
+      };
+    },
+    ComponentsAdapter<Components>
+  >;
+  render: UnaryFunction<
+    {
+      [K in keyof Components]: ReturnType<
+        <
+          Props extends Components[K] extends ComponentConstructor<infer Props>
+            ? Props
+            : never,
+        >() => JSX.Component<Props>
+      >;
+    },
+    JSX.Element
+  >;
+}
+
+export const createSlice = <
+  Data,
+  StoreSignals extends Dictionary<ComputedSignal<any>>,
+  StoreActions extends Dictionary<Action<any, any>>,
+  ApiEffects extends Dictionary<ApiEffect<any, any>>,
+  ApiActions extends Dictionary<Action<any, any>>,
+  TerminalEffects extends Dictionary<TerminalEffect<any, any>>,
+  TerminalActions extends Dictionary<Action<any, any>>,
+  Components extends Dictionary<ComponentConstructor<any>>,
+>(
+  config: SliceConfig<
+    Data,
+    StoreSignals,
+    StoreActions,
+    ApiEffects,
+    ApiActions,
+    TerminalEffects,
+    TerminalActions,
+    Components
+  >,
+) => config;
+
+export class Slice<
+  Data,
+  StoreSignals extends Dictionary<ComputedSignal<any>>,
+  StoreActions extends Dictionary<Action<any, any>>,
+  ApiEffects extends Dictionary<ApiEffect<any, any>>,
+  ApiActions extends Dictionary<Action<any, any>>,
+  TerminalEffects extends Dictionary<TerminalEffect<any, any>>,
+  TerminalActions extends Dictionary<Action<any, any>>,
+  Components extends Dictionary<ComponentConstructor<any>>,
+> {
+  private store: StoreAdapter<StoreSignals, StoreActions>;
+  private terminal: TerminalAdapter<TerminalEffects, TerminalActions>;
+
+  actions: MulticastSubject;
+  render: () => JSX.Element;
+
+  constructor(
+    public key: Promise<string>,
+    {
+      data,
+      store,
+      api,
+      terminal,
+      components,
+      render,
+    }: SliceConfig<
+      Data,
+      StoreSignals,
+      StoreActions,
+      ApiEffects,
+      ApiActions,
+      TerminalEffects,
+      TerminalActions,
+      Components
+    >,
+  ) {
+    this.store = store({
+      StoreProvider: ((context) =>
+        class extends StoreProvider<Data> {
+          constructor() {
+            super(context);
+          }
+        })({
+        actions: (this.actions = multicast(key, data)),
+      }),
+    });
+
+    this.terminal = terminal({
+      TerminalProvider: ((context) =>
+        class extends TerminalProvider<
+          StoreSignals,
+          StoreActions,
+          ApiEffects,
+          ApiActions
+        > {
+          constructor() {
+            super(context);
+          }
+        })({ api, store: this.store }),
+    });
+
+    this.render = () =>
+      createFragment({
+        children: defer(() => key).pipe(
+          map(
+            (key) =>
+              new (defineCustomElement(`${key}-slice`))(
+                render(
+                  mapValues(
+                    components({
+                      ComponentsProvider: ((context) =>
+                        class extends ComponentsProvider<
+                          StoreSignals,
+                          StoreActions,
+                          TerminalEffects,
+                          TerminalActions
+                        > {
+                          constructor() {
+                            super(context);
+                          }
+                        })({ store: this.store, terminal: this.terminal }),
+                    }).components,
+                    (componentConstructor) =>
+                      componentConstructor.predicate(key),
+                  ),
+                ),
+              ),
+          ),
+          share(),
+        ),
+      });
+  }
+}
+
+export class SliceAdapter<
+  Slices extends Dictionary<Slice<any, any, any, any, any, any, any, any>>,
+> {
+  constructor(public slices: Slices) {}
+}
+
+export class ExtendableSliceAdapter<
+  Slices extends Dictionary<Slice<any, any, any, any, any, any, any, any>>,
+> {
+  complete(): SliceAdapter<Slices> {
+    return new SliceAdapter(this.extendableSlices.complete());
+  }
+
+  constructor(
+    private extendableSlices: ExtendableDictionary<
+      Slice<any, any, any, any, any, any, any, any>,
+      Slices
+    >,
+  ) {}
+
+  provideSlices<
+    MoreSlices extends Dictionary<
+      Slice<any, any, any, any, any, any, any, any>
+    >,
+  >(
+    slices: UnaryFunction<
+      {
+        slice: <
+          Data,
+          StoreSignals extends Dictionary<ComputedSignal<any>>,
+          StoreActions extends Dictionary<Action<any, any>>,
+          ApiEffects extends Dictionary<ApiEffect<any, any>>,
+          ApiActions extends Dictionary<Action<any, any>>,
+          TerminalEffects extends Dictionary<TerminalEffect<any, any>>,
+          TerminalActions extends Dictionary<Action<any, any>>,
+          Components extends Dictionary<ComponentConstructor<any>>,
+        >(
+          constructor: UnaryFunction<
+            void,
+            SliceConfig<
+              Data,
+              StoreSignals,
+              StoreActions,
+              ApiEffects,
+              ApiActions,
+              TerminalEffects,
+              TerminalActions,
+              Components
+            >
+          >,
+        ) => Slice<
+          Data,
+          StoreSignals,
+          StoreActions,
+          ApiEffects,
+          ApiActions,
+          TerminalEffects,
+          TerminalActions,
+          Components
+        >;
+      },
+      MoreSlices
+    >,
+  ) {
+    return new ExtendableSliceAdapter(
+      this.extendableSlices.extend(
+        () =>
+          ({ property }) =>
+            slices({
+              slice: (config) => property((key) => new Slice(key, config())),
+            }),
+      ),
+    );
+  }
+}
+
+export class SliceProvider extends ExtendableSliceAdapter<{}> {
+  constructor() {
+    super(new ExtendableDictionary({}));
+  }
+}