@cascateer/core 2.3.50 → 2.4.1

package/.github/workflows/publish.yml

@@ -6,30 +6,5 @@ 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

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.50",
+  "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,11 +1,11 @@
+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 "./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);
+                    cssStyleSheets(cssModules).then((cssStyleSheets) => {
+                      const element = constructor(ctx, ...cssModules)(props);
 
                       return customElement != null
                         ? new (defineCustomElement(

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/observable/index.ts

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

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 { ComputedSignal, ProxySubject } from "../observable";
-import { Transform } from "../types";
+import { ProxySubject } from "../observable";
+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/{observable → signal}/Signal.test.ts

@@ -1,3 +1,4 @@
+import { EndoFunction } from "@cascateer/lib";
 import { identity } from "lodash";
 import {
   lastValueFrom,
@@ -8,8 +9,7 @@ import {
   toArray,
 } from "rxjs";
 import { expect, test } from "vitest";
-import { Transform } from "../types";
-import { ComputedSignal } from "./Signal";
+import { ComputedSignal } from ".";
 
 test("projection", () => {
   const signal = new ComputedSignal({
@@ -22,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),
@@ -30,8 +30,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,35 +1,23 @@
-import { clone, identity, isEqual, memoize } from "lodash";
-import { distinctUntilChanged, map, Observable, UnaryFunction } from "rxjs";
-import { ProxyObservable } from ".";
 import {
   asEnumerable,
+  EndoFunctionOperator,
   EnumerableItem,
   Enumerator,
   nonNullable,
   nthArg,
   property,
-} from "../lib";
-import { Transform } from "../types";
+} from "@cascateer/lib";
+import { clone, identity, isEqual, memoize } from "lodash";
+import { distinctUntilChanged, map, Observable, UnaryFunction } from "rxjs";
+import { ProxyObservable } from "../observable";
 
 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: EndoFunctionOperator<T, unknown>;
 
   constructor({
     value,
     enumerator = new SignalEnumerator(),
-    adapter = new SignalAdapter(),
+    pull = identity,
   }: {
     value: Observable<T>;
     enumerator?: SignalEnumerator<T>;
-    adapter?: SignalAdapter<T>;
+    pull?: EndoFunctionOperator<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: EndoFunctionOperator<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 @@
+export { ComputedSignal, Signal } from "./Signal";

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,9 +9,8 @@ import {
   ComponentsProvider,
 } 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

@@ -1,3 +1,4 @@
+import { EndoFunction, ExtendableDictionary } from "@cascateer/lib";
 import { constant, Dictionary, mapValues, tap, thru } from "lodash";
 import {
   identity,
@@ -8,8 +9,6 @@ import {
   shareReplay,
   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 } 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>;
               };
@@ -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

@@ -1,8 +1,8 @@
+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 "./observable";
+import { ComputedSignal } from "./signal";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
 import {
   Action,

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,15 +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]>;
-};
-
-export type Transform<T> = UnaryFunction<T, T>;

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 new Error(`${value} is nil`);
-  }
-
-  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];