web-idb-client 1.0.0

package/dist/schema/fields.d.ts

@@ -0,0 +1,75 @@
+import type { StoreFieldsInterface, StoreInterface } from './types';
+/** Runtime options / snapshot for a field builder. */
+export type FieldKind = 'string' | 'number' | 'boolean' | 'date' | 'array' | 'json';
+export interface FieldIndexInterface {
+    name: string;
+    keyPath: string;
+    unique?: boolean;
+    multiEntry?: boolean;
+}
+/** Declares that this field is a foreign key to another store's primary key. */
+export interface FieldRefInterface {
+    /** Target object store name */
+    store: string;
+    /** Target PK field name (documentation / validation; defaults to target store PK) */
+    field?: string;
+}
+export interface FieldInterface {
+    kind: FieldKind;
+    optional: boolean;
+    primaryKey: boolean;
+    autoIncrement: boolean;
+    /** Simple index on this field (if set) */
+    index?: FieldIndexInterface;
+    /** Optional FK metadata (does not create an IDB index by itself) */
+    ref?: FieldRefInterface;
+}
+/**
+ * Immutable field builder. Chain methods return a new instance;
+ * type parameters drive InferSelect / InferInsert / typed where.
+ */
+export declare class Field<T = unknown, TOptional extends boolean = false, TPrimary extends boolean = false, TAuto extends boolean = false, TIndexed extends boolean = false, TUnique extends boolean = false> {
+    readonly meta: Readonly<FieldInterface>;
+    /** Phantom: value type for InferSelect / InferInsert */
+    readonly _type: T;
+    readonly _optional: TOptional;
+    readonly _primary: TPrimary;
+    readonly _autoIncrement: TAuto;
+    readonly _indexed: TIndexed;
+    readonly _unique: TUnique;
+    constructor(options?: Partial<FieldInterface>);
+    cloneWith(options?: Partial<FieldInterface>): Field<T, TOptional, TPrimary, TAuto, TIndexed, TUnique>;
+    private cloneAs;
+    optional(): Field<T, true, TPrimary, TAuto, TIndexed, TUnique>;
+    primaryKey(options: {
+        autoIncrement: true;
+    }): Field<T, TOptional, true, true, TIndexed, TUnique>;
+    primaryKey(options?: {
+        autoIncrement?: false;
+    }): Field<T, TOptional, true, false, TIndexed, TUnique>;
+    /**
+     * Mark this field as a foreign key to another store.
+     * Does **not** create an IndexedDB index — chain `.index()` / `.uniqueIndex()`.
+     *
+     * Prefer passing the store object to avoid typos: `.ref(users)` / `.ref(users, 'id')`.
+     * String form `.ref('users')` remains supported.
+     */
+    ref(store: string, field?: string): Field<T, TOptional, TPrimary, TAuto, TIndexed, TUnique>;
+    ref<TFields extends StoreFieldsInterface>(store: StoreInterface<TFields>, field?: keyof TFields & string): Field<T, TOptional, TPrimary, TAuto, TIndexed, TUnique>;
+    index(name: string): Field<T, TOptional, TPrimary, TAuto, true, false>;
+    uniqueIndex(name: string): Field<T, TOptional, TPrimary, TAuto, true, true>;
+    multiEntry(name: string): Field<T, TOptional, TPrimary, TAuto, true, false>;
+}
+export type AnyField = Field<unknown, boolean, boolean, boolean, boolean, boolean>;
+/** Field builders for schema definitions. */
+export declare const field: {
+    string: () => Field<string, false, false, false, false, false>;
+    number: () => Field<number, false, false, false, false, false>;
+    boolean: () => Field<boolean, false, false, false, false, false>;
+    date: () => Field<Date, false, false, false, false, false>;
+    /** Opaque structured-cloneable value (objects, ArrayBuffer, etc.). */
+    json: <T = unknown>() => Field<T, false, false, false, false, false>;
+    array: <T_1>(_item?: Field<T_1, boolean, boolean, boolean, boolean, boolean> | undefined) => Field<T_1[], false, false, false, false, false>;
+};
+export declare function isField(value: unknown): value is AnyField;
+export declare function fieldIndexSpec(fieldName: string, fieldDef: AnyField): FieldIndexInterface | null;

package/dist/schema/fields.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldIndexSpec = exports.isField = exports.field = exports.Field = void 0;
+const DEFAULT_FIELD = {
+    kind: 'string',
+    optional: false,
+    primaryKey: false,
+    autoIncrement: false,
+};
+/**
+ * Immutable field builder. Chain methods return a new instance;
+ * type parameters drive InferSelect / InferInsert / typed where.
+ */
+class Field {
+    constructor(options) {
+        this.meta = Object.assign(Object.assign({}, DEFAULT_FIELD), options);
+    }
+    cloneWith(options) {
+        return new Field(Object.assign(Object.assign({}, this.meta), options));
+    }
+    cloneAs(options) {
+        return new Field(Object.assign(Object.assign({}, this.meta), options));
+    }
+    optional() {
+        return this.cloneAs({
+            optional: true,
+        });
+    }
+    primaryKey(options) {
+        if (options === null || options === void 0 ? void 0 : options.autoIncrement) {
+            return this.cloneAs({
+                primaryKey: true,
+                autoIncrement: true,
+            });
+        }
+        return this.cloneAs({
+            primaryKey: true,
+            autoIncrement: false,
+        });
+    }
+    ref(store, field) {
+        const storeName = typeof store === 'string' ? store : store.name;
+        return this.cloneWith({
+            ref: field ? { store: storeName, field } : { store: storeName },
+        });
+    }
+    index(name) {
+        return this.cloneAs({
+            index: { name, keyPath: '', unique: false, multiEntry: false },
+        });
+    }
+    uniqueIndex(name) {
+        return this.cloneAs({
+            index: { name, keyPath: '', unique: true, multiEntry: false },
+        });
+    }
+    multiEntry(name) {
+        return this.cloneAs({
+            index: { name, keyPath: '', unique: false, multiEntry: true },
+        });
+    }
+}
+exports.Field = Field;
+/** Field builders for schema definitions. */
+exports.field = {
+    string: () => new Field({ kind: 'string' }),
+    number: () => new Field({ kind: 'number' }),
+    boolean: () => new Field({ kind: 'boolean' }),
+    date: () => new Field({ kind: 'date' }),
+    /** Opaque structured-cloneable value (objects, ArrayBuffer, etc.). */
+    json: () => new Field({ kind: 'json' }),
+    array: (_item) => new Field({ kind: 'array' }),
+};
+function isField(value) {
+    return value instanceof Field;
+}
+exports.isField = isField;
+function fieldIndexSpec(fieldName, fieldDef) {
+    if (!fieldDef.meta.index) {
+        return null;
+    }
+    return {
+        name: fieldDef.meta.index.name,
+        keyPath: fieldName,
+        unique: fieldDef.meta.index.unique,
+        multiEntry: fieldDef.meta.index.multiEntry,
+    };
+}
+exports.fieldIndexSpec = fieldIndexSpec;
+//# sourceMappingURL=fields.js.map

package/dist/schema/fields.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fields.js","sourceRoot":"","sources":["../../src/schema/fields.ts"],"names":[],"mappings":"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"}

package/dist/schema/index.d.ts

@@ -0,0 +1,5 @@
+export * from './types';
+export * from './fields';
+export * from './define-store';
+export * from './define-db';
+export * from './infer';

package/dist/schema/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./fields"), exports);
+__exportStar(require("./define-store"), exports);
+__exportStar(require("./define-db"), exports);
+__exportStar(require("./infer"), exports);
+//# sourceMappingURL=index.js.map

package/dist/schema/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,2CAAyB;AACzB,iDAA+B;AAC/B,8CAA4B;AAC5B,0CAAwB"}

package/dist/schema/infer.d.ts

@@ -0,0 +1,131 @@
+import type { Field } from './fields';
+import type { CompoundIndexType, StoreInterface } from './types';
+type FieldOutput<F> = F extends {
+    readonly _type: infer T;
+} ? T : never;
+type SelectValue<F> = F extends Field<infer T, infer O, boolean, boolean, boolean, boolean> ? O extends true ? T | undefined : T : never;
+type IsInsertOptional<F> = F extends Field<unknown, infer O, infer P, infer A, boolean, boolean> ? O extends true ? true : P extends true ? A extends true ? true : false : false : false;
+type RequiredInsertKeys<TFields extends Record<string, Field<unknown, boolean, boolean, boolean, boolean, boolean>>> = {
+    [K in keyof TFields]: IsInsertOptional<TFields[K]> extends true ? never : K;
+}[keyof TFields];
+type OptionalInsertKeys<TFields extends Record<string, Field<unknown, boolean, boolean, boolean, boolean, boolean>>> = Exclude<keyof TFields, RequiredInsertKeys<TFields>>;
+type StoreShape = {
+    fields: Record<string, Field<unknown, boolean, boolean, boolean, boolean, boolean>>;
+    primaryKey: {
+        keyPath: string;
+    };
+};
+/** Row type returned from queries. */
+export type InferSelect<TStore extends StoreShape> = {
+    [K in keyof TStore['fields']]: SelectValue<TStore['fields'][K]>;
+};
+/** Payload accepted by insert (autoIncrement PK optional). */
+export type InferInsert<TStore extends StoreShape> = {
+    [K in RequiredInsertKeys<TStore['fields']>]: FieldOutput<TStore['fields'][K]>;
+} & {
+    [K in OptionalInsertKeys<TStore['fields']>]?: FieldOutput<TStore['fields'][K]>;
+};
+export type InferUpdate<TStore extends StoreShape> = Partial<InferSelect<TStore>>;
+export type InferClientStores<TStores extends Record<string, StoreShape>> = {
+    [K in keyof TStores]: InferSelect<TStores[K]>;
+};
+export interface RangeFilterInterface<T> {
+    equals?: T;
+    gt?: T;
+    gte?: T;
+    lt?: T;
+    lte?: T;
+    /** Aliases for gt / gte / lt / lte */
+    above?: T;
+    aboveOrEqual?: T;
+    below?: T;
+    belowOrEqual?: T;
+    /**
+     * String prefix → IDBKeyRange (lower = prefix, upper = prefix + '\\uffff').
+     * Only valid for string keys.
+     */
+    startsWith?: string;
+    /**
+     * Bound range. Default inclusive on both sides.
+     * `[lower, upper]` or `[lower, upper, lowerOpen, upperOpen]`.
+     */
+    between?: readonly [T, T] | readonly [T, T, boolean, boolean];
+}
+export type WhereValueInterface<T = unknown> = T | RangeFilterInterface<T> | IDBKeyRange;
+export type OrderDirection = 'asc' | 'desc';
+/** Runtime / internal where (not tied to a store schema). */
+export type LooseWhereInputInterface = Record<string, WhereValueInterface>;
+/** Runtime / internal orderBy. */
+export type LooseOrderByInputInterface = Record<string, OrderDirection>;
+type IsQueryableField<F> = F extends Field<unknown, boolean, infer P, boolean, infer I, boolean> ? P extends true ? true : I extends true ? true : false : false;
+type IsUniqueField<F> = F extends Field<unknown, boolean, infer P, boolean, boolean, infer U> ? P extends true ? true : U extends true ? true : false : false;
+/** PK ∪ simple/unique/multiEntry indexed field names. */
+export type QueryableKeys<TFields> = {
+    [K in keyof TFields]-?: IsQueryableField<TFields[K]> extends true ? K & string : never;
+}[keyof TFields];
+/** PK ∪ uniqueIndex field names (for findUnique). */
+export type UniqueKeys<TFields> = {
+    [K in keyof TFields]-?: IsUniqueField<TFields[K]> extends true ? K & string : never;
+}[keyof TFields];
+type FieldWhereValue<TFields, K extends keyof TFields> = WhereValueInterface<FieldOutput<TFields[K]>>;
+type SimpleWhereInput<TFields> = {
+    [K in QueryableKeys<TFields>]?: FieldWhereValue<TFields, K>;
+};
+type CompoundsOf<TStore> = TStore extends StoreInterface<infer _F, infer C extends readonly CompoundIndexType[]> ? C : readonly [];
+type FieldsOf<TStore> = TStore extends StoreInterface<infer F, infer _C> ? F : TStore extends {
+    fields: infer F;
+} ? F : never;
+type CompoundWhereFromItem<TFields, Item extends CompoundIndexType> = Item['fields'][number] extends infer K ? [K] extends [keyof TFields] ? {
+    [P in Item['fields'][number] & keyof TFields]: FieldWhereValue<TFields, P>;
+} : never : never;
+type CompoundWhereUnion<TFields, TCompounds extends readonly CompoundIndexType[]> = TCompounds[number] extends infer Item ? Item extends CompoundIndexType ? CompoundWhereFromItem<TFields, Item> : never : never;
+type NamedCompoundWhere<TFields, TCompounds extends readonly CompoundIndexType[]> = {
+    [C in TCompounds[number] as C['name']]?: {
+        [I in keyof C['fields']]: C['fields'][I] extends keyof TFields ? FieldWhereValue<TFields, C['fields'][I] & keyof TFields> : IDBValidKey;
+    };
+};
+/**
+ * Where clause typed from store schema: only PK / indexed fields,
+ * a full compound index key object, or `{ compoundIndexName: […values] }`.
+ */
+export type WhereInputInterface<TStore extends StoreInterface = StoreInterface> = SimpleWhereInput<FieldsOf<TStore>> | CompoundWhereUnion<FieldsOf<TStore>, CompoundsOf<TStore>> | NamedCompoundWhere<FieldsOf<TStore>, CompoundsOf<TStore>>;
+/** orderBy: only queryable (PK / indexed) fields. */
+export type OrderByInputInterface<TStore extends StoreInterface = StoreInterface> = {
+    [K in QueryableKeys<FieldsOf<TStore>>]?: OrderDirection;
+};
+/**
+ * findUnique where: exactly one PK or uniqueIndex field.
+ */
+export type UniqueWhereInputInterface<TStore extends StoreInterface = StoreInterface> = {
+    [K in UniqueKeys<FieldsOf<TStore>>]: {
+        [P in K]: FieldWhereValue<FieldsOf<TStore>, P & keyof FieldsOf<TStore>>;
+    };
+}[UniqueKeys<FieldsOf<TStore>>];
+export type FindManyParamsInterface<TStore extends StoreInterface = StoreInterface> = {
+    where?: WhereInputInterface<TStore>;
+    orderBy?: OrderByInputInterface<TStore>;
+    take?: number;
+    skip?: number;
+    /**
+     * When `where` and `orderBy` use different indexes, fetch by `where` then
+     * sort in memory. Can be expensive on large result sets.
+     */
+    sortInMemory?: boolean;
+};
+export type FindParamsInterface<TStore extends StoreInterface = StoreInterface> = {
+    where: WhereInputInterface<TStore>;
+    orderBy?: OrderByInputInterface<TStore>;
+    /** See FindManyParamsInterface.sortInMemory */
+    sortInMemory?: boolean;
+};
+export type UpdateParamsInterface<TStore extends StoreInterface = StoreInterface> = {
+    where: WhereInputInterface<TStore>;
+    data: Partial<InferSelect<TStore>>;
+};
+export type DeleteParamsInterface<TStore extends StoreInterface = StoreInterface> = {
+    where: WhereInputInterface<TStore>;
+};
+export type CountParamsInterface<TStore extends StoreInterface = StoreInterface> = {
+    where?: WhereInputInterface<TStore>;
+};
+export {};

package/dist/schema/infer.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=infer.js.map

package/dist/schema/infer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.js","sourceRoot":"","sources":["../../src/schema/infer.ts"],"names":[],"mappings":""}

package/dist/schema/infer.test-types.d.ts

@@ -0,0 +1,11 @@
+export declare function getTasksSchemaSnapshot(): {
+    name: string;
+    primaryKey: import("./types").PrimaryKeyInterface;
+    indexes: {
+        name: string;
+        keyPath: string | string[];
+        unique?: boolean | undefined;
+        multiEntry?: boolean | undefined;
+    }[];
+};
+export declare function getDbSchemaSnapshot(): import("./types").DeclaredDbInterface;

package/dist/schema/infer.test-types.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDbSchemaSnapshot = exports.getTasksSchemaSnapshot = void 0;
+/**
+ * Compile-time / snapshot checks for schema inference.
+ * Included in `tsc` build; does not require a test runner.
+ */
+const fields_1 = require("./fields");
+const define_store_1 = require("./define-store");
+const define_db_1 = require("./define-db");
+const tasks = (0, define_store_1.defineStore)('tasks', {
+    id: fields_1.field.number().primaryKey({ autoIncrement: true }),
+    title: fields_1.field.string(),
+    status: fields_1.field.string().index('byStatus'),
+    tags: fields_1.field.array(fields_1.field.string()).multiEntry('byTags'),
+    userId: fields_1.field.string(),
+    dueAt: fields_1.field.date().optional(),
+    email: fields_1.field.string().uniqueIndex('byEmail'),
+}, () => [(0, define_store_1.compoundIndex)('byUserDue', ['userId', 'dueAt'])]);
+/** Ensures Task has expected shape (assignability). */
+const _taskCheck = {
+    id: 1,
+    title: 't',
+    status: 'todo',
+    tags: [],
+    userId: 'u1',
+    dueAt: undefined,
+    email: 'a@b.c',
+};
+/** Ensures autoIncrement id is optional on insert. */
+const _insertCheck = {
+    title: 't',
+    status: 'todo',
+    tags: [],
+    userId: 'u1',
+    email: 'a@b.c',
+};
+const _whereOk = { status: 'todo' };
+const _wherePk = { id: 1 };
+const _whereCompound = { userId: 'u1', dueAt: new Date() };
+const _orderOk = { id: 'desc' };
+const _orderStatus = { status: 'asc' };
+const _uniqueOk = { id: 1 };
+const _uniqueEmail = { email: 'a@b.c' };
+// @ts-expect-error title is not indexed
+const _whereBad = { title: 'nope' };
+// @ts-expect-error status is not unique
+const _uniqueBad = { status: 'todo' };
+// @ts-expect-error title is not queryable for orderBy
+const _orderBad = { title: 'asc' };
+function getTasksSchemaSnapshot() {
+    return {
+        name: tasks.name,
+        primaryKey: tasks.primaryKey,
+        indexes: tasks.indexes.map((i) => (Object.assign({}, i))),
+    };
+}
+exports.getTasksSchemaSnapshot = getTasksSchemaSnapshot;
+function getDbSchemaSnapshot() {
+    return (0, define_db_1.toDeclaredDbSchema)({
+        name: 'app',
+        version: 1,
+        stores: { tasks },
+    });
+}
+exports.getDbSchemaSnapshot = getDbSchemaSnapshot;
+void _taskCheck;
+void _insertCheck;
+void _whereOk;
+void _wherePk;
+void _whereCompound;
+void _orderOk;
+void _orderStatus;
+void _uniqueOk;
+void _uniqueEmail;
+void _whereBad;
+void _uniqueBad;
+void _orderBad;
+void null;
+//# sourceMappingURL=infer.test-types.js.map

package/dist/schema/infer.test-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"infer.test-types.js","sourceRoot":"","sources":["../../src/schema/infer.test-types.ts"],"names":[],"mappings":"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"}

package/dist/schema/types.d.ts

@@ -0,0 +1,55 @@
+import type { AnyField } from './fields';
+export type { FieldKind } from './fields';
+export interface IndexInterface {
+    name: string;
+    /** Property name or path; array = compound index keyPath */
+    keyPath: string | string[];
+    unique?: boolean;
+    multiEntry?: boolean;
+}
+export interface PrimaryKeyInterface {
+    keyPath: string;
+    autoIncrement: boolean;
+}
+export type StoreFieldsInterface = Record<string, AnyField>;
+export type CompoundIndexType = {
+    name: string;
+    fields: readonly string[];
+    unique?: boolean;
+};
+export interface StoreInterface<TFields extends StoreFieldsInterface = StoreFieldsInterface, TCompounds extends readonly CompoundIndexType[] = readonly CompoundIndexType[]> {
+    readonly name: string;
+    readonly fields: TFields;
+    readonly primaryKey: PrimaryKeyInterface;
+    readonly indexes: IndexInterface[];
+    /** Phantom: compound indexes from defineStore (for typed where). */
+    readonly __compounds?: TCompounds;
+}
+export type DbStoresInterface = Record<string, StoreInterface>;
+export interface UpgradeContextInterface {
+    oldVersion: number;
+    newVersion: number;
+}
+export type UpgradeFn = (tx: IDBTransaction, ctx: UpgradeContextInterface) => void | Promise<void>;
+export interface DbConfigInterface<TStores extends DbStoresInterface = DbStoresInterface> {
+    name: string;
+    version: number;
+    stores: TStores;
+    /** Hooks keyed by target version; run when oldVersion < version */
+    upgrade?: Record<number, UpgradeFn>;
+    /**
+     * When true, `insert` / `insertMany` throw if the payload has keys
+     * that are not declared on the store schema.
+     */
+    strictInsert?: boolean;
+}
+export interface DeclaredStoreInterface {
+    name: string;
+    primaryKey: PrimaryKeyInterface;
+    indexes: IndexInterface[];
+}
+export interface DeclaredDbInterface {
+    name: string;
+    version: number;
+    stores: DeclaredStoreInterface[];
+}

package/dist/schema/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/schema/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":""}

package/dist/utils/assert-keys.d.ts

@@ -0,0 +1,3 @@
+import type { StoreInterface } from '../schema/types';
+/** Throw if `data` has keys that are not declared on the store schema. */
+export declare function assertKnownInsertKeys(store: StoreInterface, data: Record<string, unknown>): void;

package/dist/utils/assert-keys.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertKnownInsertKeys = void 0;
+const errors_1 = require("../errors");
+/** Throw if `data` has keys that are not declared on the store schema. */
+function assertKnownInsertKeys(store, data) {
+    const allowed = new Set(Object.keys(store.fields));
+    const unknown = Object.keys(data).filter((key) => !allowed.has(key));
+    if (unknown.length === 0) {
+        return;
+    }
+    throw new errors_1.IndexedDbError('QUERY_INVALID', `Unknown key(s) on insert: ${unknown.map((k) => `"${k}"`).join(', ')}. Declared fields: ${[...allowed].join(', ')}.`, { store: store.name, field: unknown[0] });
+}
+exports.assertKnownInsertKeys = assertKnownInsertKeys;
+//# sourceMappingURL=assert-keys.js.map

package/dist/utils/assert-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-keys.js","sourceRoot":"","sources":["../../src/utils/assert-keys.ts"],"names":[],"mappings":";;;AACA,sCAA2C;AAE3C,0EAA0E;AAC1E,SAAgB,qBAAqB,CACnC,KAAqB,EACrB,IAA6B;IAE7B,MAAM,OAAO,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IACnD,MAAM,OAAO,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;IACrE,IAAI,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE;QACxB,OAAO;KACR;IACD,MAAM,IAAI,uBAAc,CACtB,eAAe,EACf,6BAA6B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,sBAAsB,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,EACpH,EAAE,KAAK,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,CACzC,CAAC;AACJ,CAAC;AAdD,sDAcC"}

package/dist/utils/boolean-codec.d.ts

@@ -0,0 +1,23 @@
+import type { StoreInterface } from '../schema/types';
+import type { LooseWhereInputInterface } from '../schema/infer';
+/** IndexedDB keys cannot be boolean — store 0 | 1 instead. */
+export type StoredBoolean = 0 | 1;
+/** App boolean → IDB key (0 | 1). Passes through 0/1; leaves other values alone. */
+export declare function encodeBooleanForStorage(value: unknown): unknown;
+/**
+ * IDB value → app boolean.
+ * Accepts 0/1 and legacy true/false so old rows still decode.
+ */
+export declare function decodeBooleanFromStorage(value: unknown): boolean;
+/**
+ * Encode boolean fields in a row before writing to IndexedDB.
+ * App API stays `boolean`; storage / index keys are `0 | 1`.
+ */
+export declare function encodeRowForStorage<T extends Record<string, unknown>>(store: StoreInterface, row: T): T;
+/**
+ * Decode boolean fields after reading from IndexedDB.
+ * Treats both `0|1` and legacy `true|false` as boolean.
+ */
+export declare function decodeRowFromStorage<T extends Record<string, unknown>>(store: StoreInterface, row: T): T;
+/** Encode boolean parts of a where clause before resolving to IDBKeyRange. */
+export declare function encodeWhereForStorage(store: StoreInterface, where?: LooseWhereInputInterface): LooseWhereInputInterface | undefined;