@signaldb/svelte 2.0.0-beta.2 → 2.0.0-beta.21

package/dist/base/core/src/utils/incrementalQueryUpdate.d.ts

@@ -0,0 +1,62 @@
+import type { QueryOptions } from '../DataAdapter';
+import type { BaseItem } from '../Collection/types';
+import type Selector from '../types/Selector';
+/**
+ * The items a write created, updated or removed, from the point of view of a store.
+ *
+ * `upserts` are the *current* state of every item that still exists; `deletes` are the ids of items
+ * that no longer do. A write that changes an item's id contributes to both. Callers are responsible
+ * for that split — an "affected items" list holding an item's state from before and after a write
+ * cannot be told apart from two unrelated items here.
+ */
+export interface QueryChangeset<T extends BaseItem> {
+    upserts: T[];
+    deletes: any[];
+}
+/**
+ * Recomputes a query's result from its previous result and the change that was just written,
+ * without going back to the store.
+ *
+ * A store re-executing the query instead reads every item it holds (or every item an index points
+ * at) and filters, sorts and projects the lot — for a write that touched one row. This does the
+ * same job in the size of the write, which is what a query's result costs to keep up to date when
+ * the change that affects it is already in hand.
+ *
+ * Returns `null` when the previous result is not enough to answer, and the caller has to re-execute
+ * the query after all:
+ * - `limit` or `skip`: the result is a window onto a larger set, and an item leaving the window has
+ *   to be replaced by one the previous result never contained.
+ * - `fields` together with a `sort` the projection does not keep: the previous items are
+ *   projected, so a sort key the projection dropped is no longer there to sort by. A projection
+ *   that keeps every sort key is fine, and is the common case — a list sorted by the same date it
+ *   displays.
+ * - a `null` selector, which matches nothing and is not worth a special case.
+ * @template T - The type of the items.
+ * @param previous - The query's previous result.
+ * @param selector - The query's selector.
+ * @param options - The query's options.
+ * @param changes - The items the write created, updated or removed.
+ * @returns The new result, or `null` when the query has to be re-executed.
+ */
+export default function incrementalQueryUpdate<T extends BaseItem>(previous: T[], selector: Selector<T>, options: QueryOptions<T> | undefined, changes: QueryChangeset<T>): T[] | null;
+/**
+ * Folds a change into a query's result, whatever the query's options.
+ *
+ * The unguarded version of `incrementalQueryUpdate`, for the places where the alternative is not a
+ * more accurate answer but a wrong one — layering a write that has not been confirmed yet on top of
+ * the last confirmed result, say. For a query returning everything it matches, this is exact. For a
+ * window onto a larger set it is the closest the window itself can get: an item that no longer
+ * belongs is dropped, one that does is placed, and the window is trimmed back to its length — but
+ * an item pulled in from beyond the window is not something the window knows about.
+ *
+ * What it never does is re-examine the items already in the result. They matched when the store
+ * produced them, they still match, and asking again is both wasteful and — for a projected result,
+ * whose items no longer carry the fields the selector names — wrong.
+ * @template T - The type of the items.
+ * @param previous - The query's previous result.
+ * @param selector - The query's selector.
+ * @param options - The query's options.
+ * @param changes - The items the write created, updated or removed.
+ * @returns The resulting items.
+ */
+export declare function mergeChangesetIntoResult<T extends BaseItem>(previous: T[], selector: Selector<T>, options: QueryOptions<T> | undefined, changes: QueryChangeset<T>): T[];

package/dist/base/core/src/utils/incrementalQueryUpdate.js

@@ -0,0 +1,197 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = incrementalQueryUpdate;
+exports.mergeChangesetIntoResult = mergeChangesetIntoResult;
+const match_1 = __importDefault(require("./match"));
+const projectItems_1 = __importDefault(require("./projectItems"));
+const sortItems_1 = __importDefault(require("./sortItems"));
+/**
+ * Recomputes a query's result from its previous result and the change that was just written,
+ * without going back to the store.
+ *
+ * A store re-executing the query instead reads every item it holds (or every item an index points
+ * at) and filters, sorts and projects the lot — for a write that touched one row. This does the
+ * same job in the size of the write, which is what a query's result costs to keep up to date when
+ * the change that affects it is already in hand.
+ *
+ * Returns `null` when the previous result is not enough to answer, and the caller has to re-execute
+ * the query after all:
+ * - `limit` or `skip`: the result is a window onto a larger set, and an item leaving the window has
+ *   to be replaced by one the previous result never contained.
+ * - `fields` together with a `sort` the projection does not keep: the previous items are
+ *   projected, so a sort key the projection dropped is no longer there to sort by. A projection
+ *   that keeps every sort key is fine, and is the common case — a list sorted by the same date it
+ *   displays.
+ * - a `null` selector, which matches nothing and is not worth a special case.
+ * @template T - The type of the items.
+ * @param previous - The query's previous result.
+ * @param selector - The query's selector.
+ * @param options - The query's options.
+ * @param changes - The items the write created, updated or removed.
+ * @returns The new result, or `null` when the query has to be re-executed.
+ */
+function incrementalQueryUpdate(previous, selector, options, changes) {
+    if (selector == null)
+        return null;
+    const { sort, skip, limit, fields } = options || {};
+    if (skip != null)
+        return null;
+    if (fields != null && sort != null && !sortKeysSurviveProjection(sort, fields))
+        return null;
+    if (limit != null && !windowStaysClosed(previous, selector, options, changes))
+        return null;
+    return mergeChangesetIntoResult(previous, selector, options, changes);
+}
+/**
+ * Whether a projection keeps every field a sort is keyed on.
+ *
+ * The previous result is the projected items, so this decides whether they still carry what the
+ * sort needs. Both projection modes are covered, because `project` treats an all-zero spec as an
+ * exclusion and anything else as an inclusion:
+ *
+ * - An inclusion keeps a key when the key itself is included, or an ancestor of it is (`{a: 1}`
+ *   keeps `a.b`), and always keeps `id` unless the spec excludes it outright.
+ * - An exclusion keeps a key unless the key or an ancestor of it is excluded.
+ *
+ * Anything it cannot account for is a "no": re-executing is slower, not wrong.
+ * @template T - The type of the items.
+ * @param sort - The query's sort.
+ * @param fields - The query's projection.
+ * @returns `true` when every sort key survives the projection.
+ */
+function sortKeysSurviveProjection(sort, fields) {
+    const entries = Object.entries(fields);
+    if (entries.length === 0)
+        return true;
+    const isExclusion = entries.every(([, value]) => value === 0);
+    // `a.b.c` is kept by `a`, by `a.b` and by `a.b.c`, and dropped by any of them under an
+    // exclusion — so both modes ask about the key and each of its ancestors.
+    const pathsFor = (key) => key
+        .split('.')
+        .map((_, index, parts) => parts.slice(0, index + 1).join('.'));
+    return Object.keys(sort).every((key) => {
+        const paths = pathsFor(key);
+        if (isExclusion)
+            return paths.every(path => fields[path] !== 0);
+        if (key === 'id')
+            return fields.id !== 0;
+        return paths.some(path => fields[path] === 1);
+    });
+}
+/**
+ * Whether two items are in the given order under the given sort, deciding ties against the caller.
+ *
+ * Uses the sort itself rather than a comparator of its own: a rule about which side of a window an
+ * item falls on is only as good as its agreement with the ordering that drew the window. A tie
+ * comes back as `false`, because a tie is exactly the case where an item could belong on either
+ * side and the answer has to be taken from the store.
+ * @template T - The type of the items.
+ * @param item - The item whose position is in question.
+ * @param edge - The item at the edge of the window.
+ * @param sort - The query's sort.
+ * @returns `true` when `item` sorts strictly before `edge`.
+ */
+function sortsBefore(item, edge, sort) {
+    return (0, sortItems_1.default)([edge, item], sort)[0] === item;
+}
+/**
+ * Whether a change to a windowed query can be answered from the window alone.
+ *
+ * A window holds the first `limit` items in sort order, and nothing about what lies beyond it. An
+ * item leaving the window therefore has to be replaced by one the window has never seen, and that
+ * answer can only come from the store. An item arriving is a different matter: it takes its place
+ * and pushes the last one out, and where that one goes is not the window's problem.
+ *
+ * The one case where none of this applies is a window that was never full, because then the query
+ * already returns everything it matches and there is no "beyond".
+ * @template T - The type of the items.
+ * @param previous - The query's previous result.
+ * @param selector - The query's selector.
+ * @param options - The query's options.
+ * @param changes - The items the write created, updated or removed.
+ * @returns `true` when the new window follows from the old one and the change.
+ */
+function windowStaysClosed(previous, selector, options, changes) {
+    const { sort, limit, fields } = options || {};
+    if (limit == null || previous.length < limit)
+        return true;
+    // A full window needs an edge to compare against, and comparing needs the field the sort is on
+    // to still be there.
+    if (sort == null || fields != null)
+        return false;
+    const edge = previous.at(-1);
+    const runnerUp = previous.at(-2);
+    // Which item is *the* edge has to be beyond doubt. Two items sorting equally at the end of the
+    // window are interchangeable, and so is the question of which of them a write displaces.
+    if (runnerUp != null && !sortsBefore(runnerUp, edge, sort))
+        return false;
+    const inWindow = new Set(previous.map(item => item.id));
+    if (changes.deletes.some(id => inWindow.has(id)))
+        return false;
+    return changes.upserts.every((item) => {
+        if (item === edge)
+            return true;
+        const before = sortsBefore(item, edge, sort);
+        if (!inWindow.has(item.id)) {
+            // Coming from outside: it either takes a place inside, displacing the edge, or stays where
+            // it was. Sorting *equally* to the edge is the one answer the window cannot give, because
+            // the store may just as well have kept the edge and left this one out.
+            if (!(0, match_1.default)(item, selector))
+                return true;
+            return before || sortsBefore(edge, item, sort);
+        }
+        // An item that no longer matches leaves a place open, and what fills it is beyond the window.
+        if (!(0, match_1.default)(item, selector))
+            return false;
+        if (before)
+            return true;
+        // Not before the edge. The one item that may sit *on* the edge is the edge itself, and only
+        // while it has not actually moved — an edge that slides outwards gives up the last place, and
+        // what takes it is something the window has never seen.
+        return item.id === edge.id && !sortsBefore(edge, item, sort);
+    });
+}
+/**
+ * Folds a change into a query's result, whatever the query's options.
+ *
+ * The unguarded version of `incrementalQueryUpdate`, for the places where the alternative is not a
+ * more accurate answer but a wrong one — layering a write that has not been confirmed yet on top of
+ * the last confirmed result, say. For a query returning everything it matches, this is exact. For a
+ * window onto a larger set it is the closest the window itself can get: an item that no longer
+ * belongs is dropped, one that does is placed, and the window is trimmed back to its length — but
+ * an item pulled in from beyond the window is not something the window knows about.
+ *
+ * What it never does is re-examine the items already in the result. They matched when the store
+ * produced them, they still match, and asking again is both wasteful and — for a projected result,
+ * whose items no longer carry the fields the selector names — wrong.
+ * @template T - The type of the items.
+ * @param previous - The query's previous result.
+ * @param selector - The query's selector.
+ * @param options - The query's options.
+ * @param changes - The items the write created, updated or removed.
+ * @returns The resulting items.
+ */
+function mergeChangesetIntoResult(previous, selector, options, changes) {
+    if (selector == null)
+        return [];
+    const { sort, limit, fields } = options || {};
+    const byId = new Map();
+    previous.forEach(item => byId.set(item.id, item));
+    changes.deletes.forEach(id => byId.delete(id));
+    changes.upserts.forEach((item) => {
+        // Matched against the unprojected item: the selector is free to name fields the projection
+        // drops, and the stored result would have no answer for those.
+        if ((0, match_1.default)(item, selector)) {
+            byId.set(item.id, (0, projectItems_1.default)([item], fields)[0]);
+        }
+        else {
+            byId.delete(item.id);
+        }
+    });
+    const items = [...byId.values()];
+    const sorted = sort ? (0, sortItems_1.default)(items, sort) : items;
+    return limit == null ? sorted : sorted.slice(0, limit);
+}

package/dist/base/core/src/utils/intersection.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Computes the intersection of multiple arrays, returning an array of unique elements
+ * that are present in all the input arrays.
+ * @template T - The type of elements in the arrays.
+ * @param arrays - A variable number of arrays to compute the intersection of.
+ * @returns An array containing the unique elements found in all the input arrays.
+ *   - If no arrays are provided, returns an empty array.
+ */
+export default function intersection<T>(...arrays: T[][]): T[];

package/dist/base/core/src/utils/intersection.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = intersection;
+/**
+ * Computes the intersection of multiple arrays, returning an array of unique elements
+ * that are present in all the input arrays.
+ * @template T - The type of elements in the arrays.
+ * @param arrays - A variable number of arrays to compute the intersection of.
+ * @returns An array containing the unique elements found in all the input arrays.
+ *   - If no arrays are provided, returns an empty array.
+ */
+function intersection(...arrays) {
+    if (arrays.length === 0)
+        return [];
+    return [...new Set(arrays.reduce((a, b) => a.filter(c => b.includes(c))))];
+}

package/dist/base/core/src/utils/isEqual.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Compares two values for deep equality.
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns - Returns `true` if the two values are deeply equal, otherwise `false`.
+ * @example
+ * isEqual({ a: 1 }, { a: 1 }); // true
+ * isEqual([1, 2], [1, 2]);     // true
+ * isEqual(new Date(0), new Date(0)); // true
+ * isEqual(/abc/, /abc/);       // true
+ * isEqual({ a: 1 }, { a: 2 }); // false
+ * isEqual(null, null);         // true
+ */
+export default function isEqual<T, K>(a: T, b: K): boolean;

package/dist/base/core/src/utils/isEqual.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isEqual;
+/**
+ * Compares two values for deep equality.
+ * @param a - The first value to compare.
+ * @param b - The second value to compare.
+ * @returns - Returns `true` if the two values are deeply equal, otherwise `false`.
+ * @example
+ * isEqual({ a: 1 }, { a: 1 }); // true
+ * isEqual([1, 2], [1, 2]);     // true
+ * isEqual(new Date(0), new Date(0)); // true
+ * isEqual(/abc/, /abc/);       // true
+ * isEqual({ a: 1 }, { a: 2 }); // false
+ * isEqual(null, null);         // true
+ */
+function isEqual(a, b) {
+    if (Object.is(a, b))
+        return true;
+    if (a instanceof RegExp && b instanceof RegExp)
+        return a.toString() === b.toString();
+    if (a instanceof Date && b instanceof Date)
+        return a.getTime() === b.getTime();
+    if (typeof a !== 'object')
+        return false;
+    if (typeof b !== 'object')
+        return false;
+    if (a === null)
+        return false;
+    if (b === null)
+        return false;
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length)
+        return false;
+    for (const key of aKeys) {
+        if (!bKeys.includes(key))
+            return false;
+        if (!isEqual(a[key], b[key]))
+            return false;
+    }
+    return true;
+}

package/dist/base/core/src/utils/isFieldExpression.d.ts

@@ -0,0 +1,11 @@
+import type { FieldExpression } from '../types/Selector';
+/**
+ * Determines whether a given object is a valid field expression.
+ * A field expression is an object containing query operators supported by MongoDB-style queries.
+ * @template T - The type of the field expression.
+ * @param expression - The object to test.
+ * @returns A boolean indicating whether the object is a valid field expression.
+ *   - `true` if the object contains only recognized query operators.
+ *   - `false` otherwise.
+ */
+export default function isFieldExpression<T>(expression: any): expression is FieldExpression<T>;

package/dist/base/core/src/utils/isFieldExpression.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = isFieldExpression;
+const expressionKeys = new Set([
+    '$eq',
+    '$gt',
+    '$gte',
+    '$lt',
+    '$lte',
+    '$in',
+    '$nin',
+    '$ne',
+    '$exists',
+    '$not',
+    '$expr',
+    '$jsonSchema',
+    '$mod',
+    '$regex',
+    '$options',
+    '$text',
+    '$where',
+    '$all',
+    '$elemMatch',
+    '$size',
+    '$bitsAllClear',
+    '$bitsAllSet',
+    '$bitsAnyClear',
+    '$bitsAnySet',
+]);
+/**
+ * Determines whether a given object is a valid field expression.
+ * A field expression is an object containing query operators supported by MongoDB-style queries.
+ * @template T - The type of the field expression.
+ * @param expression - The object to test.
+ * @returns A boolean indicating whether the object is a valid field expression.
+ *   - `true` if the object contains only recognized query operators.
+ *   - `false` otherwise.
+ */
+function isFieldExpression(expression) {
+    if (typeof expression !== 'object' || expression == null) {
+        return false;
+    }
+    const keys = Object.keys(expression);
+    if (keys.length === 0) {
+        return false;
+    }
+    const hasInvalidKeys = keys.some(key => !expressionKeys.has(key));
+    if (hasInvalidKeys)
+        return false;
+    const hasValidKeys = keys.every(key => expressionKeys.has(key));
+    return hasValidKeys;
+}

package/dist/base/core/src/utils/match.d.ts

@@ -0,0 +1,12 @@
+import type Selector from '../types/Selector';
+type BaseItem = Record<string, any>;
+/**
+ * Tests whether a given item matches a specified selector.
+ * Uses the `mingo` library to evaluate the query.
+ * @template T - The type of the item being tested.
+ * @param item - The item to test against the selector.
+ * @param selector - The query selector used to match the item.
+ * @returns A boolean indicating whether the item matches the selector.
+ */
+export default function match<T extends BaseItem = BaseItem>(item: T, selector: Selector<T>): boolean;
+export {};

package/dist/base/core/src/utils/match.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = match;
+const mingo_1 = require("mingo");
+/**
+ * Tests whether a given item matches a specified selector.
+ * Uses the `mingo` library to evaluate the query.
+ * @template T - The type of the item being tested.
+ * @param item - The item to test against the selector.
+ * @param selector - The query selector used to match the item.
+ * @returns A boolean indicating whether the item matches the selector.
+ */
+function match(item, selector) {
+    const query = new mingo_1.Query(selector);
+    return query.test(item);
+}

package/dist/base/core/src/utils/modify.d.ts

@@ -0,0 +1,14 @@
+import type Modifier from '../types/Modifier';
+/**
+ * Applies a modifier to an object and returns a new modified object.
+ * @template T - The type of the object to be modified.
+ * @param item - The object to be modified.
+ * @param modifier - The modifier to apply. This can be any transformation logic.
+ * @returns - Returns a new object with the modifications applied.
+ * @example
+ * const item = { a: 1, b: 2 }
+ * const modifier = { $set: { b: 3, c: 4 } }
+ * const result = modify(item, modifier)
+ * // result: { a: 1, b: 3, c: 4 }
+ */
+export default function modify<T extends Record<string, any>>(item: T, modifier: Modifier): T;

package/dist/base/core/src/utils/modify.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = modify;
+const mingo_1 = require("mingo");
+const deepClone_1 = __importDefault(require("./deepClone"));
+/**
+ * Applies a modifier to an object and returns a new modified object.
+ * @template T - The type of the object to be modified.
+ * @param item - The object to be modified.
+ * @param modifier - The modifier to apply. This can be any transformation logic.
+ * @returns - Returns a new object with the modifications applied.
+ * @example
+ * const item = { a: 1, b: 2 }
+ * const modifier = { $set: { b: 3, c: 4 } }
+ * const result = modify(item, modifier)
+ * // result: { a: 1, b: 3, c: 4 }
+ */
+function modify(item, modifier) {
+    const hasOperators = Object.keys(modifier).some(key => key.startsWith('$'));
+    if (!hasOperators)
+        return modifier;
+    const clonedItem = (0, deepClone_1.default)(item);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+    (0, mingo_1.update)(clonedItem, modifier);
+    return clonedItem;
+}

package/dist/base/core/src/utils/project.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Projects the fields of an object based on a specified fields configuration.
+ * Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
+ * with the desired fields included or excluded, based on the configuration.
+ * @template T - The type of the object being projected.
+ * @param item - The original object to project fields from.
+ * @param fields - An object defining the fields to include (`1`) or exclude (`0`).
+ *   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
+ * @returns A new object with the specified fields included or excluded.
+ *   - If all fields are set to `0`, the excluded fields are removed from the result.
+ *   - If fields are set to `1`, only the included fields are retained.
+ */
+export default function project<T extends Record<string, any>>(item: T, fields: {
+    [P in keyof T]?: 0 | 1;
+} & Record<string, 0 | 1>): T;

package/dist/base/core/src/utils/project.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = project;
+const get_1 = __importDefault(require("./get"));
+const set_1 = __importDefault(require("./set"));
+/**
+ * Projects the fields of an object based on a specified fields configuration.
+ * Supports inclusion (`1`) and exclusion (`0`) of specific fields. Creates a new object
+ * with the desired fields included or excluded, based on the configuration.
+ * @template T - The type of the object being projected.
+ * @param item - The original object to project fields from.
+ * @param fields - An object defining the fields to include (`1`) or exclude (`0`).
+ *   - Keys are the field names, and values are either `1` (include) or `0` (exclude).
+ * @returns A new object with the specified fields included or excluded.
+ *   - If all fields are set to `0`, the excluded fields are removed from the result.
+ *   - If fields are set to `1`, only the included fields are retained.
+ */
+function project(item, fields) {
+    const allFieldsDeactivated = Object.values(fields).every(value => value === 0);
+    if (allFieldsDeactivated) {
+        const result = { ...item };
+        Object.keys(fields).forEach((key) => {
+            const fieldValue = (0, get_1.default)(item, key);
+            if (fieldValue === undefined)
+                return;
+            (0, set_1.default)(result, key, undefined, true);
+        });
+        return result;
+    }
+    const result = {};
+    Object.entries(fields).forEach(([key, value]) => {
+        const fieldValue = (0, get_1.default)(item, key);
+        if (fieldValue === undefined)
+            return;
+        if (fieldValue == null && value !== 1)
+            return;
+        (0, set_1.default)(result, key, value === 1 ? fieldValue : undefined);
+    });
+    return result;
+}

package/dist/base/core/src/utils/projectItems.d.ts

@@ -0,0 +1,12 @@
+import type { QueryOptions } from '../DataAdapter';
+import type { BaseItem } from '../Collection/types';
+/**
+ * Applies a query's field projection to a list of items, keeping the primary key unless the
+ * projection excludes it outright. Returns the items untouched when there is no projection, so a
+ * caller does not have to check for one first.
+ * @template T - The type of the items.
+ * @param items - The items to project.
+ * @param fields - The projection, or `undefined` for none.
+ * @returns The projected items.
+ */
+export default function projectItems<T extends BaseItem>(items: T[], fields: QueryOptions<T>['fields']): T[];

package/dist/base/core/src/utils/projectItems.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = projectItems;
+const project_1 = __importDefault(require("./project"));
+/**
+ * Applies a query's field projection to a list of items, keeping the primary key unless the
+ * projection excludes it outright. Returns the items untouched when there is no projection, so a
+ * caller does not have to check for one first.
+ * @template T - The type of the items.
+ * @param items - The items to project.
+ * @param fields - The projection, or `undefined` for none.
+ * @returns The projected items.
+ */
+function projectItems(items, fields) {
+    if (!fields)
+        return items;
+    const idExcluded = fields.id === 0;
+    return items.map(item => ({
+        ...idExcluded ? {} : { id: item.id },
+        ...(0, project_1.default)(item, fields),
+    }));
+}