@noy-db/hub 0.2.0-pre.2 → 0.2.0-pre.21

package/dist/derivations/index.d.ts

@@ -1,11 +1,13 @@
-export { w as withDerivation } from '../with-derivation-BKXXa8Vt.js';
-import { aw as DerivationStrategy, ax as DerivationContext } from '../types-BoFFiskX.js';
-export { ay as ArrayOutputSpec, az as DerivationRegistry, aA as DerivationStrategyHandle, aB as DerivedFromMeta, aC as OutputSpec, aD as RecordOutputSpec } from '../types-BoFFiskX.js';
-export { e as DerivationCapExceededError, f as DerivationCycleError, g as DerivationDepthError, h as DerivationOutputShapeError, i as DerivationOutputUnknownError } from '../index-BCKdioeh.js';
-import '../lazy-builder-Rpd-V3jP.js';
-import '../predicate-Dnu81tsS.js';
-import '../strategy-DSTrsZ8t.js';
+export { w as withDerivation, a as withRollup } from '../with-rollup-DJDbrxjf.js';
+import { aC as DerivationStrategy, aD as DerivationContext } from '../types-DLfWFr6U.js';
+export { aE as ArrayOutputSpec, aF as DerivationRegistry, aG as DerivationStrategyHandle, aH as DerivedFromMeta, aI as OutputSpec, aJ as RecordOutputSpec } from '../types-DLfWFr6U.js';
+export { i as DerivationCapExceededError, j as DerivationCycleError, k as DerivationDepthError, l as DerivationOutputShapeError, m as DerivationOutputUnknownError } from '../errors-Dkc_fi-S.js';
+import '../lazy-builder-ChSqcF5t.js';
+import '../predicate-BmhBSPCH.js';
+import '../strategy-54eIwox5.js';
 import '../strategy-BSxFXGzb.js';
+import '../index-BMmajblo.js';
+import '../index-Bm9hIY7t.js';
 import '@noy-db/attestation';
 
 interface RunResult {
@@ -18,7 +20,7 @@ interface RunResult {
  *
  * - `record` — the existing v1 shape: one value (or a "skipped"
  *   marker if the output was optional and `derive` returned null).
- * - `array` — the #200 shape: a list of `(key, value)` entries.
+ * - `array` — a list of `(key, value)` entries.
  *   The caller diffs these against the previously-emitted key set
  *   (loaded from the fanout sidecar) to compute deletes + upserts.
  */
@@ -28,7 +30,7 @@ interface RecordOutputResult {
     value: Record<string, unknown>;
     ok: true;
     /**
-     * `true` when an optional output (#144) returned `null` /
+     * `true` when an optional output returned `null` /
      * `undefined`. The caller deletes any previously-emitted output at
      * the same id (mirrors "tombstone for derived data"); a never-emitted
      * output is a silent no-op. `ok: true` because skipping is a

package/dist/derivations/index.js

@@ -1,19 +1,20 @@
 import {
-  withDerivation
-} from "../chunk-CXSCDO5T.js";
+  withDerivation,
+  withRollup
+} from "../chunk-YPIOFSN3.js";
 import {
   DerivationRegistry
-} from "../chunk-GIV6DWBG.js";
+} from "../chunk-S45MDEEF.js";
 import {
   DerivationExecutor
-} from "../chunk-OVZDFEOR.js";
+} from "../chunk-6QAZ5O6X.js";
 import {
   DerivationCapExceededError,
   DerivationCycleError,
   DerivationDepthError,
   DerivationOutputShapeError,
   DerivationOutputUnknownError
-} from "../chunk-W3XXT26A.js";
+} from "../chunk-OTWT6BAJ.js";
 export {
   DerivationCapExceededError,
   DerivationCycleError,
@@ -22,6 +23,7 @@ export {
   DerivationOutputShapeError,
   DerivationOutputUnknownError,
   DerivationRegistry,
-  withDerivation
+  withDerivation,
+  withRollup
 };
 //# sourceMappingURL=index.js.map

package/dist/{dev-unlock-DQCNDfFp.d.cts → dev-unlock-CY0HIZA0.d.cts}

@@ -1,4 +1,4 @@
-import { aL as Role, aM as UnlockedKeyring } from './types-DJG8HG6F.cjs';
+import { aT as Role, aU as UnlockedKeyring } from './types-DyOI6XZ_.cjs';
 
 /**
  * Session tokens —

package/dist/{dev-unlock-utkybTKb.d.ts → dev-unlock-CpKSkl2c.d.ts}

@@ -1,4 +1,4 @@
-import { aL as Role, aM as UnlockedKeyring } from './types-BoFFiskX.js';
+import { aT as Role, aU as UnlockedKeyring } from './types-DLfWFr6U.js';
 
 /**
  * Session tokens —

package/dist/discriminant-BN9REW3o.d.cts

@@ -0,0 +1,60 @@
+/**
+ * Type-guard helper for narrowing discriminated-union records.
+ *
+ * `Collection<T>` correctly threads `T` through `get` / `query` / `scan`, but
+ * accessing member-specific fields after reading from a `Collection<Union>`
+ * still requires a narrowing step in application code. In regular `.ts` files
+ * a simple `if (r.kind === 'IV')` block narrows correctly; in vue-tsc /
+ * template contexts the inline comparison is sometimes not enough, and the
+ * helper below makes the guard portable and avoids `as unknown as …` casts.
+ *
+ * **Usage with Collection<T>**
+ *
+ * ```ts
+ * import { isDiscriminant } from '@noy-db/hub'
+ *
+ * type IV = { kind: 'IV'; invoiceNo: string; amount: number }
+ * type RE = { kind: 'RE'; receiptNo: string; paidAt: string }
+ * type Receipt = IV | RE | ...
+ *
+ * const receipts = await vault.collection<Receipt>('receipts').query().toArray()
+ *
+ * // Filter approach — result is IV[], invoiceNo accessible without cast:
+ * const ivs = receipts.filter(r => isDiscriminant(r, 'kind', 'IV'))
+ * console.log(ivs[0].invoiceNo)
+ *
+ * // Branch approach:
+ * for (const r of receipts) {
+ *   if (isDiscriminant(r, 'kind', 'IV')) {
+ *     console.log(r.invoiceNo)  // r: IV here
+ *   }
+ * }
+ * ```
+ *
+ * @module
+ */
+/**
+ * Type-guard for narrowing a discriminated-union record by its discriminant.
+ *
+ * Returns `true` when `record[key] === value`, and narrows `record` to
+ * `Extract<T, Record<K, V>>` — the exact union member(s) that carry that
+ * discriminant value.
+ *
+ * The discriminant key is a parameter (not hardcoded to `'kind'`), so this
+ * works with any field name: `'kind'`, `'type'`, `'tag'`, etc.
+ *
+ * @example
+ *   const ivs = receipts.filter(r => isDiscriminant(r, 'kind', 'IV'))
+ *   // ivs: IV[]  — invoiceNo accessible, no cast needed
+ *
+ * @typeParam T - The union type of the record (e.g. `Receipt`). Both type-alias
+ *   unions and interface-extended unions work; use a `type` alias (`type Receipt = IV | RE`) for best
+ *   results.
+ * @typeParam K - The discriminant key (must be a key of `T`).
+ * @typeParam V - The discriminant value to match. The `const` modifier ensures
+ *   TypeScript infers the string literal (e.g. `'IV'`), not the full union
+ *   `T[K]`, so the predicate resolves to the exact member type.
+ */
+declare function isDiscriminant<T, K extends keyof T, const V extends T[K]>(record: T, key: K, value: V): record is Extract<T, Record<K, V>>;
+
+export { isDiscriminant as i };

package/dist/discriminant-BN9REW3o.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Type-guard helper for narrowing discriminated-union records.
+ *
+ * `Collection<T>` correctly threads `T` through `get` / `query` / `scan`, but
+ * accessing member-specific fields after reading from a `Collection<Union>`
+ * still requires a narrowing step in application code. In regular `.ts` files
+ * a simple `if (r.kind === 'IV')` block narrows correctly; in vue-tsc /
+ * template contexts the inline comparison is sometimes not enough, and the
+ * helper below makes the guard portable and avoids `as unknown as …` casts.
+ *
+ * **Usage with Collection<T>**
+ *
+ * ```ts
+ * import { isDiscriminant } from '@noy-db/hub'
+ *
+ * type IV = { kind: 'IV'; invoiceNo: string; amount: number }
+ * type RE = { kind: 'RE'; receiptNo: string; paidAt: string }
+ * type Receipt = IV | RE | ...
+ *
+ * const receipts = await vault.collection<Receipt>('receipts').query().toArray()
+ *
+ * // Filter approach — result is IV[], invoiceNo accessible without cast:
+ * const ivs = receipts.filter(r => isDiscriminant(r, 'kind', 'IV'))
+ * console.log(ivs[0].invoiceNo)
+ *
+ * // Branch approach:
+ * for (const r of receipts) {
+ *   if (isDiscriminant(r, 'kind', 'IV')) {
+ *     console.log(r.invoiceNo)  // r: IV here
+ *   }
+ * }
+ * ```
+ *
+ * @module
+ */
+/**
+ * Type-guard for narrowing a discriminated-union record by its discriminant.
+ *
+ * Returns `true` when `record[key] === value`, and narrows `record` to
+ * `Extract<T, Record<K, V>>` — the exact union member(s) that carry that
+ * discriminant value.
+ *
+ * The discriminant key is a parameter (not hardcoded to `'kind'`), so this
+ * works with any field name: `'kind'`, `'type'`, `'tag'`, etc.
+ *
+ * @example
+ *   const ivs = receipts.filter(r => isDiscriminant(r, 'kind', 'IV'))
+ *   // ivs: IV[]  — invoiceNo accessible, no cast needed
+ *
+ * @typeParam T - The union type of the record (e.g. `Receipt`). Both type-alias
+ *   unions and interface-extended unions work; use a `type` alias (`type Receipt = IV | RE`) for best
+ *   results.
+ * @typeParam K - The discriminant key (must be a key of `T`).
+ * @typeParam V - The discriminant value to match. The `const` modifier ensures
+ *   TypeScript infers the string literal (e.g. `'IV'`), not the full union
+ *   `T[K]`, so the predicate resolves to the exact member type.
+ */
+declare function isDiscriminant<T, K extends keyof T, const V extends T[K]>(record: T, key: K, value: V): record is Extract<T, Record<K, V>>;
+
+export { isDiscriminant as i };