@cascateer/core 2.3.55 → 2.4.1

package/.github/workflows/publish.yml

@@ -8,4 +8,3 @@ on:
 jobs:
   call-workflow:
     uses: cascateer/lib/.github/workflows/publish.yml@main
-    secrets: inherit

package/.github/workflows/publish2.yml

@@ -0,0 +1,36 @@
+name: Publish to NPM
+
+on:
+  workflow_call:
+  push:
+    tags:
+      - "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

package/package.json

@@ -1,34 +1,35 @@
 {
   "name": "@cascateer/core",
-  "version": "2.3.55",
+  "version": "2.4.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/cascateer/core.git"
   },
   "scripts": {
     "patch": "npm version patch && git push origin main --tags",
+    "update": "npm cache clean --force && npx npm-check-updates -u && npm i",
     "test": "vitest"
   },
   "exports": {
     ".": "./src/index.ts",
     "./jsx-runtime": "./src/jsx-runtime.ts",
     "./jsx-dev-runtime": "./src/jsx-dev-runtime.ts",
-    "./lib": "./src/lib/index.ts",
     "./operators": "./src/operators/index.ts"
   },
   "devDependencies": {
-    "@types/lodash": "^4.17.20",
+    "@types/lodash": "^4.17.24",
     "@types/object-hash": "^3.0.6",
-    "@types/react": "^19.2.14",
-    "typescript": "~5.8.3",
-    "vite": "^8.0.7",
-    "vitest": "^4.1.7"
+    "@types/react": "^19.2.16",
+    "typescript": "~6.0.3",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.8"
   },
   "dependencies": {
-    "lodash": "^4.17.21",
+    "@cascateer/lib": "^1.0.4",
+    "lodash": "^4.18.1",
     "object-hash": "^3.0.0",
     "rxjs": "^7.8.2",
     "ts-brand": "^0.2.0",
-    "uuid": "^13.0.0"
+    "uuid": "^14.0.0"
   }
 }

package/src/api.ts

@@ -1,3 +1,10 @@
+import {
+  asObservable,
+  ExtendableDictionary,
+  MaybeArray,
+  MaybeObservable,
+  property,
+} from "@cascateer/lib";
 import {
   constant,
   Dictionary,
@@ -19,10 +26,9 @@ import {
   tap,
   UnaryFunction,
 } from "rxjs";
-import { asObservable, ExtendableDictionary, property } from "./lib";
-import { memoizeHashed } from "./lib/memoizeHashed";
+import { memoize } from "./lib/memoize";
 import { ProxyObservable } from "./observable";
-import { Action, MaybeArray, MaybeObservable, ProxyEffect } from "./types";
+import { Action, ProxyEffect } from "./types";
 
 interface TagsConstructor<Args, Result> {
   (args: Args, result: Result): string[];
@@ -47,7 +53,7 @@ class Memoizable<Args, Result> {
     this.tags = isFunction(tags) ? tags : constant([tags ?? []].flat());
 
     this.subscribe = (invalidatedTags) => {
-      const memoizedEffect: ProxyEffect<Args, Result> = memoizeHashed(
+      const memoizedEffect: ProxyEffect<Args, Result> = memoize(
         (args) =>
           new ProxyObservable((pending) =>
             this.predicate(args).pipe(

package/src/app.ts

@@ -1,7 +1,7 @@
+import { property } from "@cascateer/lib";
 import { Dictionary, mapValues } from "lodash";
 import { UnaryFunction } from "rxjs";
 import { createFragment } from ".";
-import { property } from "./lib";
 import { Slice, SliceAdapter, SliceProvider } from "./slice";
 
 export class App<

package/src/component.ts

@@ -1,10 +1,10 @@
+import { ExtendableDictionary } from "@cascateer/lib";
 import { Dictionary, kebabCase } from "lodash";
 import { defer, share, UnaryFunction } from "rxjs";
 import { createFragment } from ".";
 import { ApiAdapter, ApiEffect } from "./api";
 import { cssStyleSheets } from "./css";
 import { defineCustomElement } from "./dom";
-import { ExtendableDictionary } from "./lib";
 import { ComputedSignal } from "./signal";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
 import { TerminalAdapter, TerminalEffect } from "./terminal";
@@ -33,7 +33,7 @@ export function createComponent(customElement?: string) {
               createFragment({
                 children: defer(() =>
                   Promise.all(styles).then((cssModules) =>
-                    cssStyleSheets(cssModules).then(async (cssStyleSheets) => {
+                    cssStyleSheets(cssModules).then((cssStyleSheets) => {
                       const element = constructor(ctx, ...cssModules)(props);
 
                       return customElement != null

package/src/css.ts

@@ -1,5 +1,5 @@
+import { nonNullable } from "@cascateer/lib";
 import { isObject, isString, once, tap } from "lodash";
-import { nonNullable } from "./lib";
 
 const cssImports = once(() =>
   Promise.all(

package/src/fragment.ts

@@ -1,3 +1,4 @@
+import { asArray, asObservable } from "@cascateer/lib";
 import { tap } from "lodash";
 import {
   combineLatest,
@@ -12,7 +13,6 @@ import {
   Subscription,
   switchMap,
 } from "rxjs";
-import { asArray, asObservable } from "./lib";
 import { flatMap } from "./operators";
 
 export type Leaf =

package/src/index.ts

@@ -7,4 +7,4 @@ export { Serializable, type BrandedSerializer } from "./serializable";
 export { createSlice } from "./slice";
 export { type StoreEffect } from "./store";
 export { type TerminalEffect } from "./terminal";
-export { type Action, type MaybeObservable } from "./types";
+export { type Action, type Effect } from "./types";

package/src/jsx-runtime.ts

@@ -1,3 +1,11 @@
+import {
+  asArray,
+  asObservable,
+  keys,
+  MaybeArray,
+  MaybeObservable,
+  MaybeObservableInputTuple,
+} from "@cascateer/lib";
 import { bind, camelCase, isFunction, isObject } from "lodash";
 import React, { CSSProperties } from "react";
 import {
@@ -9,13 +17,7 @@ import {
   UnaryFunction,
 } from "rxjs";
 import { Leaf, ObservableFragment } from "./fragment";
-import { asArray, asObservable, keys } from "./lib";
 import { sequence } from "./operators";
-import {
-  MaybeArray,
-  MaybeObservable,
-  MaybeObservableInputTuple,
-} from "./types";
 
 type DocumentEventListener<EventName extends keyof DocumentEventMap> =
   | Partial<Observer<DocumentEventMap[EventName]>>

package/src/lib/memoize.ts

@@ -0,0 +1,5 @@
+import * as lodash from "lodash";
+import objectHash from "object-hash";
+
+export const memoize = <T extends (...args: any) => any>(func: T) =>
+  lodash.memoize(func, (...args: Parameters<T>) => objectHash(args ?? null));

package/src/multicast.ts

@@ -1,3 +1,4 @@
+import { property } from "@cascateer/lib";
 import { partition, thru, uniq, uniqBy } from "lodash";
 import {
   distinct,
@@ -11,7 +12,6 @@ import {
   share,
 } from "rxjs";
 import { v4 } from "uuid";
-import { property } from "./lib";
 import {
   accumulate,
   exchangeWith,

package/src/operators/exchangeWith.ts

@@ -1,5 +1,5 @@
+import { property } from "@cascateer/lib";
 import { fromEvent, map, Observable, OperatorFunction } from "rxjs";
-import { property } from "../lib";
 
 export const exchangeWith =
   <InMessage, OutMessage>(

package/src/operators/multicast.ts

@@ -1,7 +1,8 @@
+import { EndoFunction } from "@cascateer/lib";
 import { concatMap, shareReplay, startWith, UnaryFunction } from "rxjs";
 import { v4 } from "uuid";
 import { ProxySubject } from "../observable";
-import { ComputedSignal, Transform } from "../signal";
+import { ComputedSignal } from "../signal";
 import { exchangeWith } from "./exchangeWith";
 import { proxyReplaySubject } from "./proxyReplaySubject";
 
@@ -22,7 +23,7 @@ interface MulticastActions<Data> {
     };
   };
   transformAction: {
-    predicate: Transform<Data>;
+    predicate: EndoFunction<Data>;
     data: {
       key: string;
       args: string;

package/src/signal/Signal.test.ts

@@ -1,3 +1,4 @@
+import { EndoFunction } from "@cascateer/lib";
 import { identity } from "lodash";
 import {
   lastValueFrom,
@@ -8,7 +9,7 @@ import {
   toArray,
 } from "rxjs";
 import { expect, test } from "vitest";
-import { ComputedSignal, Transform } from ".";
+import { ComputedSignal } from ".";
 
 test("projection", () => {
   const signal = new ComputedSignal({
@@ -21,7 +22,7 @@ test("projection", () => {
 });
 
 test("transformation", () => {
-  const transforms = new ReplaySubject<Transform<any>>();
+  const transforms = new ReplaySubject<EndoFunction<any>>();
   const signal = new ComputedSignal({
     value: transforms.pipe(
       startWith(identity),

package/src/signal/Signal.ts

@@ -1,15 +1,15 @@
-import { clone, identity, isEqual, memoize } from "lodash";
-import { distinctUntilChanged, map, Observable, UnaryFunction } from "rxjs";
 import {
   asEnumerable,
+  EndoFunctionOperator,
   EnumerableItem,
   Enumerator,
   nonNullable,
   nthArg,
   property,
-} from "../lib";
+} from "@cascateer/lib";
+import { clone, identity, isEqual, memoize } from "lodash";
+import { distinctUntilChanged, map, Observable, UnaryFunction } from "rxjs";
 import { ProxyObservable } from "../observable";
-import { TransformOperator } from "../signal";
 
 class SignalEnumerator<T> {
   constructor(private predicate: Enumerator<T> = nthArg(1)) {}
@@ -30,7 +30,7 @@ export class Signal<T> extends ProxyObservable<T> {
   }
 
   enumerator: SignalEnumerator<T>;
-  pull: TransformOperator<T, unknown>;
+  pull: EndoFunctionOperator<T, unknown>;
 
   constructor({
     value,
@@ -39,7 +39,7 @@ export class Signal<T> extends ProxyObservable<T> {
   }: {
     value: Observable<T>;
     enumerator?: SignalEnumerator<T>;
-    pull?: TransformOperator<T, unknown>;
+    pull?: EndoFunctionOperator<T, unknown>;
   }) {
     super(value);
 
@@ -49,7 +49,7 @@ export class Signal<T> extends ProxyObservable<T> {
 
   private map<U>(
     project: UnaryFunction<T, U>,
-    lift: TransformOperator<U, T>,
+    lift: EndoFunctionOperator<U, T>,
     enumerate?: Enumerator<U>,
   ): Signal<U> {
     return new Signal({

package/src/signal/index.ts

@@ -1,10 +1 @@
-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

@@ -1,3 +1,4 @@
+import { ExtendableDictionary } from "@cascateer/lib";
 import { Dictionary, mapValues } from "lodash";
 import { defer, map, share, UnaryFunction } from "rxjs";
 import { createFragment } from ".";
@@ -8,7 +9,6 @@ import {
   ComponentsProvider,
 } from "./component";
 import { defineCustomElement } from "./dom";
-import { ExtendableDictionary } from "./lib";
 import { multicast, MulticastSubject } from "./operators";
 import { ComputedSignal } from "./signal";
 import { StoreAdapter, StoreProvider } from "./store";

package/src/store.ts

@@ -1,3 +1,4 @@
+import { EndoFunction, ExtendableDictionary } from "@cascateer/lib";
 import { constant, Dictionary, mapValues, tap, thru } from "lodash";
 import {
   identity,
@@ -8,7 +9,6 @@ import {
   shareReplay,
   UnaryFunction,
 } from "rxjs";
-import { ExtendableDictionary } from "./lib";
 import {
   flatMap,
   MulticastAction,
@@ -16,7 +16,7 @@ import {
   sequence,
 } from "./operators";
 import { Serializable } from "./serializable";
-import { ComputedSignal, Signal, Transform } from "./signal";
+import { ComputedSignal, Signal } from "./signal";
 import { Action } from "./types";
 
 export type StoreEffect<Result> = () => Signal<Result>;
@@ -70,7 +70,7 @@ export class ExtendableStoreAdapter<
             },
             void
           >;
-          register: UnaryFunction<(args: any) => Transform<any>, void>;
+          register: UnaryFunction<(args: any) => EndoFunction<any>, void>;
         }
       >;
     },
@@ -115,7 +115,7 @@ export class ExtendableStoreAdapter<
                     ? T
                     : never,
                 >(
-                  predicate: UnaryFunction<Args, Transform<T>>,
+                  predicate: UnaryFunction<Args, EndoFunction<T>>,
                   config?: { sameOrigin?: boolean },
                 ) => Action<Args, any>;
               };

package/src/terminal.ts

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

package/src/types.ts

@@ -1,8 +1,7 @@
 import { Dictionary, mapValues, tap } from "lodash";
 import { combineLatest, ReplaySubject, switchMap, UnaryFunction } from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
-import { ObservableInput } from "rxjs/internal/types";
-import { memoizeHashed } from "./lib/memoizeHashed";
+import { memoize } from "./lib/memoize";
 import { ProxyObservable } from "./observable";
 import { accumulate, every, some } from "./operators";
 
@@ -36,7 +35,7 @@ export class ProxyEffectInterceptor extends ReplaySubject<
     effects: Effects,
   ): ProxyEffects<Effects> {
     return mapValues(effects, (effect) =>
-      memoizeHashed((args) =>
+      memoize((args) =>
         tap(
           new ProxyObservable(effect(args), (target, receiver) =>
             combineLatest([target.pending, receiver.refCount]).pipe(every()),
@@ -65,13 +64,3 @@ 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]>;
-};

package/src/lib/Enumerable.ts

@@ -1,23 +0,0 @@
-export class Enumerable<T> extends Array<
-  T extends readonly (infer Index)[] ? Index : never
-> {
-  constructor(value: T) {
-    super();
-
-    this.push(...(Array.isArray(value) ? value : []));
-  }
-}
-
-export type EnumerableItem<
-  T,
-  Index extends number = number,
-> = Enumerable<T>[Index];
-
-export interface Enumerator<T> {
-  <Index extends number>(
-    item: EnumerableItem<T, Index>,
-    index: Index,
-  ): PropertyKey;
-}
-
-export const asEnumerable = <T>(value: T) => new Enumerable<T>(value);

package/src/lib/ExtendableDictionary.ts

@@ -1,56 +0,0 @@
-import { Dictionary, once } from "lodash";
-import { AsyncSubject, lastValueFrom, UnaryFunction } from "rxjs";
-import { keys } from "./keys";
-
-export type Extend<T, U> = Omit<T, keyof U> & U;
-
-export class ExtendableDictionary<T, U extends Dictionary<T>> {
-  constructor(
-    public currentValue: U,
-    private value = new AsyncSubject<Dictionary<T>>(),
-  ) {}
-
-  complete = once((): U => {
-    this.value.next(this.currentValue);
-    this.value.complete();
-
-    return this.currentValue;
-  });
-
-  extend<V extends Dictionary<T>>(
-    value: (
-      currentValue: U,
-    ) => ({
-      property,
-    }: {
-      property: (constructor: UnaryFunction<Promise<string>, T>) => T;
-    }) => V,
-  ) {
-    return new ExtendableDictionary<T, Extend<U, V>>(
-      {
-        ...this.currentValue,
-        ...value(this.currentValue)({
-          property: (constructor) => {
-            const property = constructor(
-              lastValueFrom(this.value).then(
-                (value) =>
-                  new Promise<string>((resolve, reject) => {
-                    for (const key of keys(value)) {
-                      if (value[key] === property) {
-                        return resolve(key);
-                      }
-                    }
-
-                    reject();
-                  }),
-              ),
-            );
-
-            return property;
-          },
-        }),
-      },
-      this.value,
-    );
-  }
-}

package/src/lib/chunkWith.ts

@@ -1,26 +0,0 @@
-import { Comparator, uniqWith } from "lodash";
-
-export const chunkWith = <T>(
-  actions: T[],
-  comparator?: Comparator<T>,
-): T[][] => [
-  ...{
-    *[Symbol.iterator]() {
-      const prevActions = new Array<T>();
-
-      if (actions.length == 0) {
-        return;
-      }
-
-      for (const action of actions) {
-        if (uniqWith([...prevActions, action], comparator).length === 1) {
-          prevActions.push(action);
-        } else {
-          yield prevActions.splice(0, prevActions.length, action);
-        }
-      }
-
-      yield prevActions;
-    },
-  },
-];

package/src/lib/index.ts

@@ -1,29 +0,0 @@
-import { Observable, of } from "rxjs";
-import { isObservable } from "rxjs/internal/util/isObservable";
-import { MaybeArray, MaybeObservable } from "../types";
-
-export { chunkWith } from "./chunkWith";
-export {
-  asEnumerable,
-  type Enumerable,
-  type EnumerableItem,
-  type Enumerator,
-} from "./Enumerable";
-export { ExtendableDictionary } from "./ExtendableDictionary";
-export { keys } from "./keys";
-export { nthArg } from "./nthArg";
-export { property } from "./property";
-
-export const asArray = <T>(array: MaybeArray<T>): Array<T> =>
-  Array.isArray(array) ? array : [array];
-
-export const asObservable = <T>(value: MaybeObservable<T>): Observable<T> =>
-  isObservable(value) ? value : of(value);
-
-export const nonNullable = <T>(value: T): NonNullable<T> => {
-  if (value == null) {
-    throw null;
-  }
-
-  return value;
-};

package/src/lib/keys.ts

@@ -1,7 +0,0 @@
-export const keys = <T>(value: T) => [
-  ...{
-    *[Symbol.iterator]() {
-      for (const key in value) yield key;
-    },
-  },
-];

package/src/lib/memoizeHashed.ts

@@ -1,5 +0,0 @@
-import { memoize } from "lodash";
-import objectHash from "object-hash";
-
-export const memoizeHashed = <T extends (...args: any) => any>(func: T) =>
-  memoize(func, (...args: Parameters<T>) => objectHash(args ?? null));

package/src/lib/nthArg.ts

@@ -1,6 +0,0 @@
-export function nthArg<T>(n: 0): (arg0: T) => T;
-export function nthArg<T>(n: 1): (arg0: any, arg1: T) => T;
-export function nthArg<T>(n: 2): (arg0: any, arg1: any, arg2: T) => T;
-export function nthArg<T>(n: number): (...args: any[]) => T {
-  return (...args) => args[n];
-}

package/src/lib/property.ts

@@ -1,4 +0,0 @@
-export const property =
-  <T, K extends keyof T = keyof T>(key: K) =>
-  (value: T): T[K] =>
-    value[key];