joist-core 2.3.0 → 2.4.0

package/build/utils.cjs

@@ -0,0 +1,204 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_relations_Reference = require("./relations/Reference.cjs");
+const require_relations_ReactiveField = require("./relations/ReactiveField.cjs");
+require("./relations/index.cjs");
+const require_EntityManager = require("./EntityManager.cjs");
+require("./Entity.cjs");
+//#region src/utils.ts
+/**
+* Given a `MaybePromise` of T, invoke `callback` against `T` either immediately or via `then`.
+*
+* This is the same as:
+*
+* ```
+* const r = await maybePromise;
+* return callback(r;;
+* ```
+*
+* But saves an `await` if `maybePromise` is not actually a promise.
+*/
+function maybePromiseThen(promiseOrObj, callback) {
+	return promiseOrObj instanceof Promise ? promiseOrObj.then(callback) : callback(promiseOrObj);
+}
+function failIfAnyRejected(results) {
+	const rejects = results.filter((r) => r.status === "rejected");
+	if (rejects.length > 0 && rejects[0].status === "rejected") throw rejects[0].reason;
+	return results.map((r) => r.value);
+}
+function getOrSet(record, key, defaultValue) {
+	if (record[key] === void 0) record[key] = defaultValue instanceof Function ? defaultValue() : defaultValue;
+	return record[key];
+}
+/** Defines a getter that replaces itself with its computed value on first access. */
+function defineLazyGetter(obj, key, build) {
+	Object.defineProperty(obj, key, {
+		configurable: true,
+		get: function getLazyProperty() {
+			const value = build();
+			Object.defineProperty(obj, key, {
+				configurable: true,
+				value
+			});
+			return value;
+		}
+	});
+}
+/**
+* A utility to ensure a Promise-returning method actually returns a promise and doesn't
+* early exit. Using `async function` guarantees these semantics, but sometimes we avoid
+* `async` as a likely-premature optimization to avoid the overhead.
+*/
+function tryResolve(fn) {
+	try {
+		return Promise.resolve(fn());
+	} catch (e) {
+		return Promise.reject(e);
+	}
+}
+/** Returns whether `obj` has at least one key, without allocating a keys array. */
+function hasAnyKey(obj) {
+	for (const _ in obj) return true;
+	return false;
+}
+function fail(message) {
+	throw new Error(message || "Failed");
+}
+function remove(array, t) {
+	const index = array.indexOf(t);
+	if (index > -1) array.splice(index, 1);
+}
+function maybeRemove(array, t) {
+	if (array) remove(array, t);
+}
+function maybeAdd(array, t) {
+	if (!array.includes(t)) array.push(t);
+}
+function clear(array) {
+	array.splice(0, array.length);
+}
+/** Returns 0 inclusive to n exclusive. */
+function zeroTo(n) {
+	return [...Array(n).keys()];
+}
+function groupBy(list, fn, valueFn) {
+	const result = /* @__PURE__ */ new Map();
+	list.forEach((o) => {
+		const group = fn(o);
+		if (!result.has(group)) result.set(group, []);
+		result.get(group).push(valueFn === void 0 ? o : valueFn(o));
+	});
+	return result;
+}
+function indexBy(list, fn, valueFn) {
+	const result = /* @__PURE__ */ new Map();
+	list.forEach((o) => {
+		const group = fn(o);
+		result.set(group, valueFn === void 0 ? o : valueFn(o));
+	});
+	return result;
+}
+function batched(list, n) {
+	const result = [];
+	for (let i = 0; i < list.length; i += n) result.push(list.slice(i, i + n));
+	return result;
+}
+function partition(array, f) {
+	const trueElements = [];
+	const falseElements = [];
+	array.forEach((el) => {
+		if (f(el)) trueElements.push(el);
+		else falseElements.push(el);
+	});
+	return [trueElements, falseElements];
+}
+function toArray(maybeArray) {
+	return Array.isArray(maybeArray) ? maybeArray : maybeArray === void 0 || maybeArray === null ? [] : [maybeArray];
+}
+function assertNever(x) {
+	throw new Error("Unexpected object: " + x);
+}
+function abbreviation(tableName) {
+	return tableName.split("_").map((w) => w[0]).join("");
+}
+/**
+* Utility method for casting `entity` to a `New` entity.
+*
+* Note that we don't actually do any runtime checks; a very simple one would be if the id is undefined,
+* but we want this method to be used in tests that are post-`flush` but still "know" the entity is
+* effectively new / fully loaded.
+*
+* Granted, we could do a runtime check that all relations are loaded.
+*/
+function asNew(entity) {
+	return entity;
+}
+function compareValues(av, bv, direction) {
+	const d = direction === "ASC" ? 1 : -1;
+	if (require_relations_ReactiveField.isReactiveField(av)) av = !av.isSet ? -1 : av.get;
+	if (require_relations_ReactiveField.isReactiveField(bv)) bv = !bv.isSet ? -1 : bv.get;
+	if (require_relations_Reference.isReference(av) && require_relations_Reference.isReference(bv)) {
+		const aIsNew = av.isLoaded && av.get?.isNewEntity;
+		const bIsNew = bv.isLoaded && bv.get?.isNewEntity;
+		if (!(aIsNew && bIsNew || !aIsNew && !bIsNew)) {
+			if (aIsNew) return 1 * d;
+			if (bIsNew) return -1 * d;
+		}
+		av = av.idTaggedMaybe ?? (av.isLoaded && av.get?.toString()) ?? void 0;
+		bv = bv.idTaggedMaybe ?? (bv.isLoaded && bv.get?.toString()) ?? void 0;
+	}
+	if (!require_EntityManager.isDefined(av) || !require_EntityManager.isDefined(bv)) return !av && !bv ? 0 : (!av ? 1 : -1) * d;
+	else if (typeof av === "number" && typeof bv === "number") return (av - bv) * d;
+	else if (typeof av === "string" && typeof bv === "string") return av.localeCompare(bv) * d;
+	else if (av instanceof Date && bv instanceof Date) return (av.getTime() - bv.getTime()) * d;
+	else throw new Error(`Unsupported sortBy values ${av}, ${bv}`);
+}
+/** A ~naive deep merge that requires already-normalized hints and will mutate `source`. */
+function mergeNormalizedHints(target, source) {
+	for (const key of Object.keys(source)) if (target[key]) mergeNormalizedHints(source[key], target[key]);
+	Object.assign(target, source);
+}
+const newLine = /\n/g;
+const doubleSpace = /  +/g;
+function cleanStringValue(value) {
+	let s = typeof value !== "string" && value !== void 0 && value !== null ? String(value) : value;
+	s = typeof s === "string" ? s.trim() : s;
+	return s === "" || s === null ? void 0 : s;
+}
+/** Strips new lines/indentation from our `UPDATE` string; doesn't do any actual SQL param escaping/etc. */
+function cleanSql(sql) {
+	return sql.trim().replace(newLine, "").replace(doubleSpace, " ");
+}
+function flatAndUnique(list) {
+	const result = /* @__PURE__ */ new Set();
+	for (const c of list) if (Array.isArray(c)) for (const e of c) result.add(e);
+	else if (c) result.add(c);
+	return result;
+}
+//#endregion
+exports.abbreviation = abbreviation;
+exports.asNew = asNew;
+exports.assertNever = assertNever;
+exports.batched = batched;
+exports.cleanSql = cleanSql;
+exports.cleanStringValue = cleanStringValue;
+exports.clear = clear;
+exports.compareValues = compareValues;
+exports.defineLazyGetter = defineLazyGetter;
+exports.fail = fail;
+exports.failIfAnyRejected = failIfAnyRejected;
+exports.flatAndUnique = flatAndUnique;
+exports.getOrSet = getOrSet;
+exports.groupBy = groupBy;
+exports.hasAnyKey = hasAnyKey;
+exports.indexBy = indexBy;
+exports.maybeAdd = maybeAdd;
+exports.maybePromiseThen = maybePromiseThen;
+exports.maybeRemove = maybeRemove;
+exports.mergeNormalizedHints = mergeNormalizedHints;
+exports.partition = partition;
+exports.remove = remove;
+exports.toArray = toArray;
+exports.tryResolve = tryResolve;
+exports.zeroTo = zeroTo;
+
+//# sourceMappingURL=utils.cjs.map

package/build/utils.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.cjs","names":["isReactiveField","isReference","isDefined"],"sources":["../src/utils.ts"],"sourcesContent":["import { type Entity } from \"src/Entity.ts\";\nimport { isDefined } from \"src/EntityManager.ts\";\nimport type { New } from \"src/loading/loadHints.ts\";\nimport type { OrderBy } from \"src/queries/find/EntityFilter.ts\";\nimport { isReactiveField, isReference } from \"src/relations/index.ts\";\n\nexport type MaybePromise<T> = T | Promise<T>;\n\n/**\n * Given a `MaybePromise` of T, invoke `callback` against `T` either immediately or via `then`.\n *\n * This is the same as:\n *\n * ```\n * const r = await maybePromise;\n * return callback(r;;\n * ```\n *\n * But saves an `await` if `maybePromise` is not actually a promise.\n */\nexport function maybePromiseThen<T, U>(promiseOrObj: MaybePromise<T>, callback: (obj: T) => U): MaybePromise<U> {\n  return promiseOrObj instanceof Promise ? promiseOrObj.then(callback) : callback(promiseOrObj);\n}\n\nexport function failIfAnyRejected<T>(results: PromiseSettledResult<T>[]): T[] {\n  const rejects = results.filter((r) => r.status === \"rejected\");\n  // For now just throw the 1st rejection; this should be pretty rare\n  if (rejects.length > 0 && rejects[0].status === \"rejected\") {\n    throw rejects[0].reason;\n  }\n  return results.map((r) => (r as PromiseFulfilledResult<T>).value);\n}\n\nexport function getOrSet<T extends Record<keyof unknown, unknown>>(\n  record: T,\n  key: keyof T,\n  defaultValue: T[keyof T] | (() => T[keyof T]),\n): T[keyof T] {\n  if (record[key] === undefined) {\n    record[key] = defaultValue instanceof Function ? defaultValue() : defaultValue;\n  }\n  return record[key];\n}\n\n/** Defines a getter that replaces itself with its computed value on first access. */\nexport function defineLazyGetter<T extends object, K extends keyof T>(obj: T, key: K, build: () => T[K]): void {\n  Object.defineProperty(obj, key, {\n    configurable: true,\n    get: function getLazyProperty() {\n      const value = build();\n      Object.defineProperty(obj, key, { configurable: true, value });\n      return value;\n    },\n  });\n}\n\n/**\n * A utility to ensure a Promise-returning method actually returns a promise and doesn't\n * early exit. Using `async function` guarantees these semantics, but sometimes we avoid\n * `async` as a likely-premature optimization to avoid the overhead.\n */\nexport function tryResolve<T>(fn: () => T): Promise<T> {\n  try {\n    return Promise.resolve(fn());\n  } catch (e) {\n    return Promise.reject(e);\n  }\n}\n\n/** Returns whether `obj` has at least one key, without allocating a keys array. */\nexport function hasAnyKey(obj: Record<any, any> | undefined): boolean {\n  for (const _ in obj) return true;\n  return false;\n}\n\nexport function fail(message?: string): never {\n  throw new Error(message || \"Failed\");\n}\n\nexport function remove<T>(array: T[], t: T): void {\n  const index = array.indexOf(t);\n  if (index > -1) {\n    array.splice(index, 1);\n  }\n}\n\nexport function maybeRemove<T>(array: T[] | undefined, t: T): void {\n  if (array) remove(array, t);\n}\n\nexport function maybeAdd<T>(array: T[], t: T): void {\n  if (!array.includes(t)) {\n    array.push(t);\n  }\n}\n\nexport function clear<T>(array: T[]): void {\n  array.splice(0, array.length);\n}\n\n/** Returns 0 inclusive to n exclusive. */\nexport function zeroTo(n: number): number[] {\n  return [...Array(n).keys()];\n}\n\nexport function groupBy<T, Y = T, K = string>(list: readonly T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y[]> {\n  const result = new Map<K, Y[]>();\n  list.forEach((o) => {\n    const group = fn(o);\n    if (!result.has(group)) {\n      result.set(group, []);\n    }\n    result.get(group)!.push(valueFn === undefined ? (o as any as Y) : valueFn(o));\n  });\n  return result;\n}\n\nexport function indexBy<T, Y = T, K = string>(list: T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y> {\n  const result = new Map<K, Y>();\n  list.forEach((o) => {\n    const group = fn(o);\n    result.set(group, valueFn === undefined ? (o as any as Y) : valueFn(o));\n  });\n  return result;\n}\n\nexport function batched<T>(list: Array<T>, n: number): T[][] {\n  const result = [] as T[][];\n  for (let i = 0; i < list.length; i += n) {\n    result.push(list.slice(i, i + n));\n  }\n  return result;\n}\n\nexport function partition<T>(array: ReadonlyArray<T>, f: (el: T) => boolean): [T[], T[]] {\n  const trueElements: T[] = [];\n  const falseElements: T[] = [];\n  array.forEach((el) => {\n    if (f(el)) {\n      trueElements.push(el);\n    } else {\n      falseElements.push(el);\n    }\n  });\n  return [trueElements, falseElements];\n}\n\n// Utility function to wrap an object or value in an array, unless it's already an array\nexport function toArray<T>(maybeArray: T | T[] | undefined | null): T[] {\n  return Array.isArray(maybeArray) ? maybeArray : maybeArray === undefined || maybeArray === null ? [] : [maybeArray];\n}\n\n// Utility type to strip off null and defined and infer only T.\nexport type NullOrDefinedOr<T> = T | null | undefined;\n\nexport function assertNever(x: never): never {\n  throw new Error(\"Unexpected object: \" + x);\n}\n\nexport function abbreviation(tableName: string): string {\n  return tableName\n    .split(\"_\")\n    .map((w) => w[0])\n    .join(\"\");\n}\n\n/**\n * Utility method for casting `entity` to a `New` entity.\n *\n * Note that we don't actually do any runtime checks; a very simple one would be if the id is undefined,\n * but we want this method to be used in tests that are post-`flush` but still \"know\" the entity is\n * effectively new / fully loaded.\n *\n * Granted, we could do a runtime check that all relations are loaded.\n */\nexport function asNew<T extends Entity>(entity: T): New<T> {\n  return entity as New<T>;\n}\n\nexport function compareValues(av: any, bv: any, direction: OrderBy): number {\n  const d = direction === \"ASC\" ? 1 : -1;\n  if (isReactiveField(av)) {\n    av = !av.isSet ? -1 : av.get;\n  }\n  if (isReactiveField(bv)) {\n    bv = !bv.isSet ? -1 : bv.get;\n  }\n  if (isReference(av) && isReference(bv)) {\n    const aIsNew = av.isLoaded && (av as any).get?.isNewEntity;\n    const bIsNew = bv.isLoaded && (bv as any).get?.isNewEntity;\n    const bothSame = (aIsNew && bIsNew) || (!aIsNew && !bIsNew);\n    if (!bothSame) {\n      if (aIsNew) return 1 * d; // New entities are always \"greater than\" loaded entities\n      if (bIsNew) return -1 * d; // Loaded entities are always \"less than\" new entities\n    }\n    av = av.idTaggedMaybe ?? (av.isLoaded && (av as any).get?.toString()) ?? undefined;\n    bv = bv.idTaggedMaybe ?? (bv.isLoaded && (bv as any).get?.toString()) ?? undefined;\n  }\n  if (!isDefined(av) || !isDefined(bv)) {\n    return !av && !bv ? 0 : (!av ? 1 : -1) * d;\n  } else if (typeof av === \"number\" && typeof bv === \"number\") {\n    return (av - bv) * d;\n  } else if (typeof av === \"string\" && typeof bv === \"string\") {\n    return av.localeCompare(bv) * d;\n  } else if (av instanceof Date && bv instanceof Date) {\n    return ((av as Date).getTime() - (bv as Date).getTime()) * d;\n  } else {\n    throw new Error(`Unsupported sortBy values ${av}, ${bv}`);\n  }\n}\n\n/** A ~naive deep merge that requires already-normalized hints and will mutate `source`. */\n// https://gist.github.com/ahtcx/0cd94e62691f539160b32ecda18af3d6\nexport function mergeNormalizedHints(target: any, source: any): void {\n  for (const key of Object.keys(source)) {\n    // We assume both target & source are already normalized, i.e. we won't have\n    // source=\"books\" and target={books: \"title\"}. They will both be {books: ...}.\n    if (target[key]) {\n      mergeNormalizedHints(source[key], target[key]);\n    }\n  }\n  Object.assign(target, source);\n}\n\nconst newLine = /\\n/g;\nconst doubleSpace = /  +/g;\n\nexport function cleanStringValue(value: unknown): string | undefined {\n  // If this is not a string, coerce it -- or maybe fail?\n  let s = typeof value !== \"string\" && value !== undefined && value !== null ? String(value) : value;\n  // We always trim to remove leading/trailing spaces\n  s = typeof s === \"string\" ? s.trim() : s;\n  // And if it's empty string, we swap to undefined (null in the db)\n  return s === \"\" || s === null ? undefined : s;\n}\n\n/** Strips new lines/indentation from our `UPDATE` string; doesn't do any actual SQL param escaping/etc. */\nexport function cleanSql(sql: string): string {\n  return sql.trim().replace(newLine, \"\").replace(doubleSpace, \" \");\n}\n\n// Collections return an array, so do a hot-path `.flat()`\nexport function flatAndUnique<T extends unknown>(list: (T | T[] | undefined)[]): Set<T> {\n  const result = new Set<T>();\n  for (const c of list) {\n    if (Array.isArray(c)) {\n      for (const e of c) result.add(e);\n    } else if (c) {\n      result.add(c);\n    }\n  }\n  return result;\n}\n"],"mappings":"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"}

package/build/utils.d.cts

@@ -0,0 +1,65 @@
+import { OrderBy } from "./queries/find/EntityFilter.cjs";
+import { New } from "./loading/loadHints.cjs";
+import { Entity } from "./Entity.cjs";
+//#region src/utils.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Given a `MaybePromise` of T, invoke `callback` against `T` either immediately or via `then`.
+ *
+ * This is the same as:
+ *
+ * ```
+ * const r = await maybePromise;
+ * return callback(r;;
+ * ```
+ *
+ * But saves an `await` if `maybePromise` is not actually a promise.
+ */
+declare function maybePromiseThen<T, U>(promiseOrObj: MaybePromise<T>, callback: (obj: T) => U): MaybePromise<U>;
+declare function failIfAnyRejected<T>(results: PromiseSettledResult<T>[]): T[];
+declare function getOrSet<T extends Record<keyof unknown, unknown>>(record: T, key: keyof T, defaultValue: T[keyof T] | (() => T[keyof T])): T[keyof T];
+/** Defines a getter that replaces itself with its computed value on first access. */
+declare function defineLazyGetter<T extends object, K extends keyof T>(obj: T, key: K, build: () => T[K]): void;
+/**
+ * A utility to ensure a Promise-returning method actually returns a promise and doesn't
+ * early exit. Using `async function` guarantees these semantics, but sometimes we avoid
+ * `async` as a likely-premature optimization to avoid the overhead.
+ */
+declare function tryResolve<T>(fn: () => T): Promise<T>;
+/** Returns whether `obj` has at least one key, without allocating a keys array. */
+declare function hasAnyKey(obj: Record<any, any> | undefined): boolean;
+declare function fail(message?: string): never;
+declare function remove<T>(array: T[], t: T): void;
+declare function maybeRemove<T>(array: T[] | undefined, t: T): void;
+declare function maybeAdd<T>(array: T[], t: T): void;
+declare function clear<T>(array: T[]): void;
+/** Returns 0 inclusive to n exclusive. */
+declare function zeroTo(n: number): number[];
+declare function groupBy<T, Y = T, K = string>(list: readonly T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y[]>;
+declare function indexBy<T, Y = T, K = string>(list: T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y>;
+declare function batched<T>(list: Array<T>, n: number): T[][];
+declare function partition<T>(array: ReadonlyArray<T>, f: (el: T) => boolean): [T[], T[]];
+declare function toArray<T>(maybeArray: T | T[] | undefined | null): T[];
+type NullOrDefinedOr<T> = T | null | undefined;
+declare function assertNever(x: never): never;
+declare function abbreviation(tableName: string): string;
+/**
+ * Utility method for casting `entity` to a `New` entity.
+ *
+ * Note that we don't actually do any runtime checks; a very simple one would be if the id is undefined,
+ * but we want this method to be used in tests that are post-`flush` but still "know" the entity is
+ * effectively new / fully loaded.
+ *
+ * Granted, we could do a runtime check that all relations are loaded.
+ */
+declare function asNew<T extends Entity>(entity: T): New<T>;
+declare function compareValues(av: any, bv: any, direction: OrderBy): number;
+/** A ~naive deep merge that requires already-normalized hints and will mutate `source`. */
+declare function mergeNormalizedHints(target: any, source: any): void;
+declare function cleanStringValue(value: unknown): string | undefined;
+/** Strips new lines/indentation from our `UPDATE` string; doesn't do any actual SQL param escaping/etc. */
+declare function cleanSql(sql: string): string;
+declare function flatAndUnique<T extends unknown>(list: (T | T[] | undefined)[]): Set<T>;
+//#endregion
+export { MaybePromise, NullOrDefinedOr, abbreviation, asNew, assertNever, batched, cleanSql, cleanStringValue, clear, compareValues, defineLazyGetter, fail, failIfAnyRejected, flatAndUnique, getOrSet, groupBy, hasAnyKey, indexBy, maybeAdd, maybePromiseThen, maybeRemove, mergeNormalizedHints, partition, remove, toArray, tryResolve, zeroTo };
+//# sourceMappingURL=utils.d.cts.map

package/build/utils.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.cts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;KAMY,aAAa,KAAK,IAAI,QAAQ;;;;;;;;;;;;;iBAc1B,iBAAiB,GAAG,GAAG,cAAc,aAAa,IAAI,WAAW,KAAK,MAAM,IAAI,aAAa;iBAI7F,kBAAkB,GAAG,SAAS,qBAAqB,OAAO;iBAS1D,SAAS,UAAU,gCACjC,QAAQ,GACR,WAAW,GACX,cAAc,QAAQ,YAAY,QAAQ,MACzC,QAAQ;;iBAQK,iBAAiB,kBAAkB,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,EAAE;;;;;;iBAgBrF,WAAW,GAAG,UAAU,IAAI,QAAQ;;iBASpC,UAAU,KAAK;iBAKf,KAAK;iBAIL,OAAO,GAAG,OAAO,KAAK,GAAG;iBAOzB,YAAY,GAAG,OAAO,iBAAiB,GAAG;iBAI1C,SAAS,GAAG,OAAO,KAAK,GAAG;iBAM3B,MAAM,GAAG,OAAO;;iBAKhB,OAAO;iBAIP,QAAQ,GAAG,IAAI,GAAG,YAAY,eAAe,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBAYlG,QAAQ,GAAG,IAAI,GAAG,YAAY,MAAM,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBASzF,QAAQ,GAAG,MAAM,MAAM,IAAI,YAAY;iBAQvC,UAAU,GAAG,OAAO,cAAc,IAAI,IAAI,IAAI,iBAAiB,KAAK;iBAcpE,QAAQ,GAAG,YAAY,IAAI,yBAAyB;KAKxD,gBAAgB,KAAK;iBAEjB,YAAY;iBAIZ,aAAa;;;;;;;;;;iBAgBb,MAAM,UAAU,QAAQ,QAAQ,IAAI,IAAI;iBAIxC,cAAc,SAAS,SAAS,WAAW;;iBAkC3C,qBAAqB,aAAa;iBAclC,iBAAiB;;iBAUjB,SAAS;iBAKT,cAAc,mBAAmB,OAAO,IAAI,qBAAqB,IAAI"}

package/build/utils.d.mts

@@ -0,0 +1,65 @@
+import { OrderBy } from "./queries/find/EntityFilter.mjs";
+import { New } from "./loading/loadHints.mjs";
+import { Entity } from "./Entity.mjs";
+//#region src/utils.d.ts
+type MaybePromise<T> = T | Promise<T>;
+/**
+ * Given a `MaybePromise` of T, invoke `callback` against `T` either immediately or via `then`.
+ *
+ * This is the same as:
+ *
+ * ```
+ * const r = await maybePromise;
+ * return callback(r;;
+ * ```
+ *
+ * But saves an `await` if `maybePromise` is not actually a promise.
+ */
+declare function maybePromiseThen<T, U>(promiseOrObj: MaybePromise<T>, callback: (obj: T) => U): MaybePromise<U>;
+declare function failIfAnyRejected<T>(results: PromiseSettledResult<T>[]): T[];
+declare function getOrSet<T extends Record<keyof unknown, unknown>>(record: T, key: keyof T, defaultValue: T[keyof T] | (() => T[keyof T])): T[keyof T];
+/** Defines a getter that replaces itself with its computed value on first access. */
+declare function defineLazyGetter<T extends object, K extends keyof T>(obj: T, key: K, build: () => T[K]): void;
+/**
+ * A utility to ensure a Promise-returning method actually returns a promise and doesn't
+ * early exit. Using `async function` guarantees these semantics, but sometimes we avoid
+ * `async` as a likely-premature optimization to avoid the overhead.
+ */
+declare function tryResolve<T>(fn: () => T): Promise<T>;
+/** Returns whether `obj` has at least one key, without allocating a keys array. */
+declare function hasAnyKey(obj: Record<any, any> | undefined): boolean;
+declare function fail(message?: string): never;
+declare function remove<T>(array: T[], t: T): void;
+declare function maybeRemove<T>(array: T[] | undefined, t: T): void;
+declare function maybeAdd<T>(array: T[], t: T): void;
+declare function clear<T>(array: T[]): void;
+/** Returns 0 inclusive to n exclusive. */
+declare function zeroTo(n: number): number[];
+declare function groupBy<T, Y = T, K = string>(list: readonly T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y[]>;
+declare function indexBy<T, Y = T, K = string>(list: T[], fn: (x: T) => K, valueFn?: (x: T) => Y): Map<K, Y>;
+declare function batched<T>(list: Array<T>, n: number): T[][];
+declare function partition<T>(array: ReadonlyArray<T>, f: (el: T) => boolean): [T[], T[]];
+declare function toArray<T>(maybeArray: T | T[] | undefined | null): T[];
+type NullOrDefinedOr<T> = T | null | undefined;
+declare function assertNever(x: never): never;
+declare function abbreviation(tableName: string): string;
+/**
+ * Utility method for casting `entity` to a `New` entity.
+ *
+ * Note that we don't actually do any runtime checks; a very simple one would be if the id is undefined,
+ * but we want this method to be used in tests that are post-`flush` but still "know" the entity is
+ * effectively new / fully loaded.
+ *
+ * Granted, we could do a runtime check that all relations are loaded.
+ */
+declare function asNew<T extends Entity>(entity: T): New<T>;
+declare function compareValues(av: any, bv: any, direction: OrderBy): number;
+/** A ~naive deep merge that requires already-normalized hints and will mutate `source`. */
+declare function mergeNormalizedHints(target: any, source: any): void;
+declare function cleanStringValue(value: unknown): string | undefined;
+/** Strips new lines/indentation from our `UPDATE` string; doesn't do any actual SQL param escaping/etc. */
+declare function cleanSql(sql: string): string;
+declare function flatAndUnique<T extends unknown>(list: (T | T[] | undefined)[]): Set<T>;
+//#endregion
+export { MaybePromise, NullOrDefinedOr, abbreviation, asNew, assertNever, batched, cleanSql, cleanStringValue, clear, compareValues, defineLazyGetter, fail, failIfAnyRejected, flatAndUnique, getOrSet, groupBy, hasAnyKey, indexBy, maybeAdd, maybePromiseThen, maybeRemove, mergeNormalizedHints, partition, remove, toArray, tryResolve, zeroTo };
+//# sourceMappingURL=utils.d.mts.map

package/build/utils.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.mts","names":[],"sources":["../src/utils.ts"],"mappings":";;;;KAMY,aAAa,KAAK,IAAI,QAAQ;;;;;;;;;;;;;iBAc1B,iBAAiB,GAAG,GAAG,cAAc,aAAa,IAAI,WAAW,KAAK,MAAM,IAAI,aAAa;iBAI7F,kBAAkB,GAAG,SAAS,qBAAqB,OAAO;iBAS1D,SAAS,UAAU,gCACjC,QAAQ,GACR,WAAW,GACX,cAAc,QAAQ,YAAY,QAAQ,MACzC,QAAQ;;iBAQK,iBAAiB,kBAAkB,gBAAgB,GAAG,KAAK,GAAG,KAAK,GAAG,aAAa,EAAE;;;;;;iBAgBrF,WAAW,GAAG,UAAU,IAAI,QAAQ;;iBASpC,UAAU,KAAK;iBAKf,KAAK;iBAIL,OAAO,GAAG,OAAO,KAAK,GAAG;iBAOzB,YAAY,GAAG,OAAO,iBAAiB,GAAG;iBAI1C,SAAS,GAAG,OAAO,KAAK,GAAG;iBAM3B,MAAM,GAAG,OAAO;;iBAKhB,OAAO;iBAIP,QAAQ,GAAG,IAAI,GAAG,YAAY,eAAe,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBAYlG,QAAQ,GAAG,IAAI,GAAG,YAAY,MAAM,KAAK,KAAK,GAAG,MAAM,GAAG,WAAW,GAAG,MAAM,IAAI,IAAI,GAAG;iBASzF,QAAQ,GAAG,MAAM,MAAM,IAAI,YAAY;iBAQvC,UAAU,GAAG,OAAO,cAAc,IAAI,IAAI,IAAI,iBAAiB,KAAK;iBAcpE,QAAQ,GAAG,YAAY,IAAI,yBAAyB;KAKxD,gBAAgB,KAAK;iBAEjB,YAAY;iBAIZ,aAAa;;;;;;;;;;iBAgBb,MAAM,UAAU,QAAQ,QAAQ,IAAI,IAAI;iBAIxC,cAAc,SAAS,SAAS,WAAW;;iBAkC3C,qBAAqB,aAAa;iBAclC,iBAAiB;;iBAUjB,SAAS;iBAKT,cAAc,mBAAmB,OAAO,IAAI,qBAAqB,IAAI"}