@cascateer/core 2.3.50 → 2.3.55

package/.github/workflows/publish.yml

@@ -6,30 +6,6 @@ on:
       - "v*"
 
 jobs:
-  publish:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-      id-token: write
-
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-node@v6
-        with:
-          node-version: "24"
-          registry-url: "https://registry.npmjs.org"
-
-      - name: Verify version matches tag
-        run: |
-          TAG="${GITHUB_REF#refs/tags/}"
-          VERSION="${TAG#v}"
-          FILE_VERSION=$(node -p "require('./package.json').version")
-          if [ "$VERSION" != "$FILE_VERSION" ]; then
-            echo "Version mismatch: tag=$VERSION, package.json=$FILE_VERSION"
-            exit 1
-          fi
-
-      - name: Publish to NPM
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-        run: npm publish --access public --provenance
+  call-workflow:
+    uses: cascateer/lib/.github/workflows/publish.yml@main
+    secrets: inherit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.3.50",
+  "version": "2.3.55",
   "repository": {
     "type": "git",
     "url": "https://github.com/cascateer/core.git"

package/src/component.ts

@@ -5,7 +5,7 @@ import { ApiAdapter, ApiEffect } from "./api";
 import { cssStyleSheets } from "./css";
 import { defineCustomElement } from "./dom";
 import { ExtendableDictionary } from "./lib";
-import { ComputedSignal } from "./observable";
+import { ComputedSignal } from "./signal";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
 import { TerminalAdapter, TerminalEffect } from "./terminal";
 import { Action, Effect } from "./types";
@@ -18,23 +18,23 @@ export function createComponent(customElement?: string) {
   const withTemplate =
     <Styles extends Promise<unknown>[]>(...styles: Styles) =>
     <
-      Deps extends Dictionary<Effect<any, any> | Action<any, any>>,
+      Context extends Dictionary<Effect<any, any> | Action<any, any>>,
       Props extends JSX.Props,
     >(
       constructor: (
-        deps: Deps,
+        ctx: Context,
         ...classNamesList: { -readonly [K in keyof Styles]: Awaited<Styles[K]> }
       ) => JSX.Component<Props>,
     ) =>
       class extends ComponentConstructor<Props> {
-        constructor(deps: Deps) {
+        constructor(ctx: Context) {
           super(
             (key) => (props) =>
               createFragment({
                 children: defer(() =>
                   Promise.all(styles).then((cssModules) =>
                     cssStyleSheets(cssModules).then(async (cssStyleSheets) => {
-                      const element = constructor(deps, ...cssModules)(props);
+                      const element = constructor(ctx, ...cssModules)(props);
 
                       return customElement != null
                         ? new (defineCustomElement(

package/src/lib/index.ts

@@ -22,7 +22,7 @@ export const asObservable = <T>(value: MaybeObservable<T>): Observable<T> =>
 
 export const nonNullable = <T>(value: T): NonNullable<T> => {
   if (value == null) {
-    throw new Error(`${value} is nil`);
+    throw null;
   }
 
   return value;

package/src/observable/index.ts

@@ -1,3 +1,2 @@
 export { ProxyObservable } from "./ProxyObservable";
 export { ProxySubject } from "./ProxySubject";
-export { ComputedSignal, Signal } from "./Signal";

package/src/operators/multicast.ts

@@ -1,7 +1,7 @@
 import { concatMap, shareReplay, startWith, UnaryFunction } from "rxjs";
 import { v4 } from "uuid";
-import { ComputedSignal, ProxySubject } from "../observable";
-import { Transform } from "../types";
+import { ProxySubject } from "../observable";
+import { ComputedSignal, Transform } from "../signal";
 import { exchangeWith } from "./exchangeWith";
 import { proxyReplaySubject } from "./proxyReplaySubject";
 

package/src/{observable → signal}/Signal.test.ts

@@ -8,8 +8,7 @@ import {
   toArray,
 } from "rxjs";
 import { expect, test } from "vitest";
-import { Transform } from "../types";
-import { ComputedSignal } from "./Signal";
+import { ComputedSignal, Transform } from ".";
 
 test("projection", () => {
   const signal = new ComputedSignal({
@@ -30,8 +29,8 @@ test("transformation", () => {
     ),
   }).property("number");
 
-  transforms.next(signal.adapter.lift((number) => number + 1));
-  transforms.next(signal.adapter.lift((number) => number + 2));
+  transforms.next(signal.pull((number) => number + 1));
+  transforms.next(signal.pull((number) => number + 2));
   transforms.complete();
 
   return lastValueFrom(signal.pipe(toArray())).then((numbers) =>

package/src/{observable → signal}/Signal.ts

@@ -1,6 +1,5 @@
 import { clone, identity, isEqual, memoize } from "lodash";
 import { distinctUntilChanged, map, Observable, UnaryFunction } from "rxjs";
-import { ProxyObservable } from ".";
 import {
   asEnumerable,
   EnumerableItem,
@@ -9,27 +8,16 @@ import {
   nthArg,
   property,
 } from "../lib";
-import { Transform } from "../types";
+import { ProxyObservable } from "../observable";
+import { TransformOperator } from "../signal";
 
 class SignalEnumerator<T> {
-  constructor(private enumerator: Enumerator<T> = nthArg(1)) {}
+  constructor(private predicate: Enumerator<T> = nthArg(1)) {}
 
   findIndex = (key: PropertyKey) => (value: T) =>
-    asEnumerable(value).map(this.enumerator).indexOf(key);
+    asEnumerable(value).map(this.predicate).indexOf(key);
 
-  enumerate = (value: T) => asEnumerable(value).map(this.enumerator);
-}
-
-class SignalAdapter<T> {
-  constructor(
-    public lift: (transform: Transform<T>) => Transform<unknown> = identity,
-  ) {}
-
-  connect<U>(
-    connector: UnaryFunction<Transform<U>, Transform<T>>,
-  ): SignalAdapter<U> {
-    return new SignalAdapter((transform) => this.lift(connector(transform)));
-  }
+  enumerate = (value: T) => asEnumerable(value).map(this.predicate);
 }
 
 export class Signal<T> extends ProxyObservable<T> {
@@ -42,42 +30,42 @@ export class Signal<T> extends ProxyObservable<T> {
   }
 
   enumerator: SignalEnumerator<T>;
-  adapter: SignalAdapter<T>;
+  pull: TransformOperator<T, unknown>;
 
   constructor({
     value,
     enumerator = new SignalEnumerator(),
-    adapter = new SignalAdapter(),
+    pull = identity,
   }: {
     value: Observable<T>;
     enumerator?: SignalEnumerator<T>;
-    adapter?: SignalAdapter<T>;
+    pull?: TransformOperator<T, unknown>;
   }) {
     super(value);
 
     this.enumerator = enumerator;
-    this.adapter = adapter;
+    this.pull = pull;
   }
 
-  private project<U>(
-    projector: UnaryFunction<T, U>,
-    connector: UnaryFunction<Transform<U>, Transform<T>>,
-    enumerator?: Enumerator<U>,
+  private map<U>(
+    project: UnaryFunction<T, U>,
+    lift: TransformOperator<U, T>,
+    enumerate?: Enumerator<U>,
   ): Signal<U> {
     return new Signal({
-      value: this.pipe(map(projector), distinctUntilChanged()),
-      enumerator: new SignalEnumerator(enumerator),
-      adapter: this.adapter.connect(connector),
+      value: this.pipe(map(project), distinctUntilChanged()),
+      enumerator: new SignalEnumerator(enumerate),
+      pull: (transform) => this.pull(lift(transform)),
     });
   }
 
   protected property<K extends keyof T>(
     key: K,
-    enumerator?: Enumerator<T[K]>,
+    enumerate?: Enumerator<T[K]>,
   ): Signal<T[K]> {
     const findProperty: UnaryFunction<T, T[K]> = property(key);
 
-    return this.project(
+    return this.map(
       findProperty,
       (transform) => (value) => {
         value = clone(value);
@@ -86,19 +74,19 @@ export class Signal<T> extends ProxyObservable<T> {
 
         return value;
       },
-      enumerator,
+      enumerate,
     );
   }
 
   protected item(
     key: PropertyKey,
-    enumerator?: Enumerator<EnumerableItem<T>>,
+    enumerate?: Enumerator<EnumerableItem<T>>,
   ): Signal<EnumerableItem<T>> {
     const findIndex = this.enumerator.findIndex(key);
     const findItem: UnaryFunction<T, EnumerableItem<T>> = (value) =>
       nonNullable(asEnumerable(value)[findIndex(value)]);
 
-    return this.project(
+    return this.map(
       findItem,
       (transform) => (value) => {
         if (Array.isArray((value = clone(value)))) {
@@ -107,14 +95,14 @@ export class Signal<T> extends ProxyObservable<T> {
 
         return value;
       },
-      enumerator,
+      enumerate,
     );
   }
 
   protected collection<K extends keyof EnumerableItem<T>>(
     key: K,
   ): Signal<EnumerableItem<T>[K][]> {
-    return this.project(
+    return this.map(
       (value) => asEnumerable(value).map(property(key)),
       (transform) => (value) => {
         if (Array.isArray((value = clone(value)))) {
@@ -150,16 +138,16 @@ export class Signal<T> extends ProxyObservable<T> {
 export class ComputedSignal<T> extends Signal<T> {
   property<K extends keyof T>(
     key: K,
-    enumerator?: Enumerator<T[K]>,
+    enumerate?: Enumerator<T[K]>,
   ): ComputedSignal<T[K]> {
-    return new ComputedSignal(super.property(key, enumerator));
+    return new ComputedSignal(super.property(key, enumerate));
   }
 
   item(
     key: PropertyKey,
-    enumerator?: Enumerator<EnumerableItem<T>>,
+    enumerate?: Enumerator<EnumerableItem<T>>,
   ): ComputedSignal<EnumerableItem<T>> {
-    return new ComputedSignal(super.item(key, enumerator));
+    return new ComputedSignal(super.item(key, enumerate));
   }
 
   collection<K extends keyof EnumerableItem<T>>(

package/src/signal/index.ts

@@ -0,0 +1,10 @@
+import { UnaryFunction } from "rxjs";
+
+export { ComputedSignal, Signal } from "./Signal";
+
+export interface Transform<T> extends UnaryFunction<T, T> {}
+
+export interface TransformOperator<T, U> extends UnaryFunction<
+  Transform<T>,
+  Transform<U>
+> {}

package/src/slice.ts

@@ -9,8 +9,8 @@ import {
 } from "./component";
 import { defineCustomElement } from "./dom";
 import { ExtendableDictionary } from "./lib";
-import { ComputedSignal } from "./observable";
 import { multicast, MulticastSubject } from "./operators";
+import { ComputedSignal } from "./signal";
 import { StoreAdapter, StoreProvider } from "./store";
 import { TerminalAdapter, TerminalEffect, TerminalProvider } from "./terminal";
 import { Action } from "./types";

package/src/store.ts

@@ -9,7 +9,6 @@ import {
   UnaryFunction,
 } from "rxjs";
 import { ExtendableDictionary } from "./lib";
-import { ComputedSignal, Signal } from "./observable";
 import {
   flatMap,
   MulticastAction,
@@ -17,7 +16,8 @@ import {
   sequence,
 } from "./operators";
 import { Serializable } from "./serializable";
-import { Action, Transform } from "./types";
+import { ComputedSignal, Signal, Transform } from "./signal";
+import { Action } from "./types";
 
 export type StoreEffect<Result> = () => Signal<Result>;
 
@@ -143,7 +143,7 @@ export class ExtendableStoreAdapter<
                         update: (predicate, config = {}) =>
                           thru(this.context.transform(key), (transform) => {
                             transform.register((args) =>
-                              signal.adapter.lift(predicate(args)),
+                              signal.pull(predicate(args)),
                             );
 
                             return (args) =>

package/src/terminal.ts

@@ -2,7 +2,7 @@ import { Dictionary } from "lodash";
 import { UnaryFunction } from "rxjs";
 import { ApiAdapter, ApiEffect } from "./api";
 import { ExtendableDictionary } from "./lib";
-import { ComputedSignal } from "./observable";
+import { ComputedSignal } from "./signal";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
 import {
   Action,

package/src/types.ts

@@ -75,5 +75,3 @@ 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>;