@cascateer/lib 1.0.1

package/.github/workflows/publish.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

@@ -0,0 +1,21 @@
+{
+  "name": "@cascateer/lib",
+  "version": "1.0.1",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/cascateer/lib.git"
+  },
+  "scripts": {
+    "patch": "npm version patch && git push origin main --tags"
+  },
+  "exports": {
+    ".": "./src/index.ts"
+  },
+  "dependencies": {
+    "lodash": "^4.18.1",
+    "rxjs": "^7.8.2"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.24"
+  }
+}

package/src/ExtendableDictionary.ts

@@ -0,0 +1,56 @@
+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/array.ts

@@ -0,0 +1,4 @@
+export type MaybeArray<T> = T | T[];
+
+export const asArray = <T>(array: MaybeArray<T>): Array<T> =>
+  Array.isArray(array) ? array : [array];

package/src/chunkWith.ts

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

package/src/index.ts

@@ -0,0 +1,13 @@
+export { asArray, type MaybeArray } from "./array";
+export { chunkWith } from "./chunkWith";
+export { ExtendableDictionary } from "./ExtendableDictionary";
+export { keys } from "./keys";
+export { nonNullable, nonNullableAsync } from "./nonNullable";
+export { nthArg } from "./nthArg";
+export {
+  asObservable,
+  type MaybeObservable,
+  type MaybeObservableInput,
+  type MaybeObservableInputTuple,
+} from "./observable";
+export { property } from "./property";

package/src/keys.ts

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

package/src/nonNullable.ts

@@ -0,0 +1,10 @@
+export const nonNullable = <T>(value: T): NonNullable<T> => {
+  if (value == null) {
+    throw null;
+  }
+
+  return value;
+};
+
+export const nonNullableAsync = async <T>(value: T): Promise<NonNullable<T>> =>
+  nonNullable(value);

package/src/nthArg.ts

@@ -0,0 +1,6 @@
+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/observable.ts

@@ -0,0 +1,12 @@
+import { isObservable, Observable, ObservableInput, of } from "rxjs";
+
+export const asObservable = <T>(value: MaybeObservable<T>): Observable<T> =>
+  isObservable(value) ? value : of(value);
+
+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/property.ts

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

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "es2016",
+    "module": "commonjs",
+    "types": ["node"],
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "noUncheckedIndexedAccess": true
+  }
+}