yummies 7.16.2 → 7.18.0

package/assert.cjs

@@ -26,6 +26,7 @@ let yummies_common = require("yummies/common");
 */
 var _exports_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	AssertionError: () => AssertionError,
+	array: () => array,
 	boolean: () => boolean,
 	defined: () => defined,
 	fail: () => fail,
@@ -35,6 +36,7 @@ var _exports_exports = /* @__PURE__ */ require_chunk.__exportAll({
 	notNull: () => notNull,
 	notUndefined: () => notUndefined,
 	number: () => number,
+	object: () => object,
 	ok: () => ok,
 	string: () => string,
 	symbol: () => symbol,
@@ -110,6 +112,24 @@ function string(value, message) {
 	if (!yummies_type_guard.typeGuard.isString(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a string"));
 }
 /**
+* Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function object(value, message) {
+	if (!yummies_type_guard.typeGuard.isObject(value)) throw new AssertionError(resolveAssertMessage(message, "Expected an object"));
+}
+/**
+* Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function array(value, message) {
+	if (!yummies_type_guard.typeGuard.isArray(value)) throw new AssertionError(resolveAssertMessage(message, "Expected an array"));
+}
+/**
 * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.
 *
 * @param value Value to narrow.

package/assert.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"assert.cjs","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,SAAA,GAAA,eAAA,cAAoB,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,mBAAA,UAAU,QAAQ,UAAU,CAC9B,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,CAAC,mBAAA,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,mBAAA,UAAU,OAAO,MAAM,CACzB,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,mBAAA,UAAU,YAAY,MAAM,CAC9B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SAC0B;AAC1B,KAAI,CAAC,mBAAA,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}
+{"version":3,"file":"assert.cjs","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject, Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function object<T extends AnyObject = AnyObject>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isObject(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an object'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function array<T extends any[] = any[]>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isArray(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an array'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,SAAA,GAAA,eAAA,cAAoB,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,mBAAA,UAAU,QAAQ,UAAU,CAC9B,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,CAAC,mBAAA,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,mBAAA,UAAU,OAAO,MAAM,CACzB,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,mBAAA,UAAU,YAAY,MAAM,CAC9B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACoB;AACpB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,MACd,OACA,SACoB;AACpB,KAAI,CAAC,mBAAA,UAAU,QAAQ,MAAM,CAC3B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SAC0B;AAC1B,KAAI,CAAC,mBAAA,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,mBAAA,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}

package/assert.d.ts

@@ -1,4 +1,4 @@
-import { MaybeFn, Maybe } from 'yummies/types';
+import { MaybeFn, Maybe, AnyObject } from 'yummies/types';
 
 /**
  * ---header-docs-section---
@@ -77,6 +77,20 @@ declare function notUndefined<T>(value: T | undefined, message?: MaybeFn<string>
  * @param message Optional message or lazy message factory.
  */
 declare function string(value: unknown, message?: MaybeFn<string>): asserts value is string;
+/**
+ * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.
+ *
+ * @param value Value to narrow.
+ * @param message Optional message or lazy message factory.
+ */
+declare function object<T extends AnyObject = AnyObject>(value: unknown, message?: MaybeFn<string>): asserts value is T;
+/**
+ * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.
+ *
+ * @param value Value to narrow.
+ * @param message Optional message or lazy message factory.
+ */
+declare function array<T extends any[] = any[]>(value: unknown, message?: MaybeFn<string>): asserts value is T;
 /**
  * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.
  *
@@ -137,6 +151,7 @@ declare function instanceOf<T>(value: unknown, ctor: abstract new (...args: neve
 
 type _exports_AssertionError = AssertionError;
 declare const _exports_AssertionError: typeof AssertionError;
+declare const _exports_array: typeof array;
 declare const _exports_boolean: typeof boolean;
 declare const _exports_defined: typeof defined;
 declare const _exports_fail: typeof fail;
@@ -145,6 +160,7 @@ declare const _exports_invariant: typeof invariant;
 declare const _exports_notNull: typeof notNull;
 declare const _exports_notUndefined: typeof notUndefined;
 declare const _exports_number: typeof number;
+declare const _exports_object: typeof object;
 declare const _exports_ok: typeof ok;
 declare const _exports_string: typeof string;
 declare const _exports_symbol: typeof symbol;
@@ -152,6 +168,7 @@ declare const _exports_unreachable: typeof unreachable;
 declare namespace _exports {
   export {
     _exports_AssertionError as AssertionError,
+    _exports_array as array,
     _exports_boolean as boolean,
     _exports_defined as defined,
     _exports_fail as fail,
@@ -161,6 +178,7 @@ declare namespace _exports {
     _exports_notNull as notNull,
     _exports_notUndefined as notUndefined,
     _exports_number as number,
+    _exports_object as object,
     _exports_ok as ok,
     _exports_string as string,
     _exports_symbol as symbol,

package/assert.js

@@ -25,6 +25,7 @@ import { callFunction } from "yummies/common";
 */
 var _exports_exports = /* @__PURE__ */ __exportAll({
 	AssertionError: () => AssertionError,
+	array: () => array,
 	boolean: () => boolean,
 	defined: () => defined,
 	fail: () => fail,
@@ -34,6 +35,7 @@ var _exports_exports = /* @__PURE__ */ __exportAll({
 	notNull: () => notNull,
 	notUndefined: () => notUndefined,
 	number: () => number,
+	object: () => object,
 	ok: () => ok,
 	string: () => string,
 	symbol: () => symbol,
@@ -109,6 +111,24 @@ function string(value, message) {
 	if (!typeGuard.isString(value)) throw new AssertionError(resolveAssertMessage(message, "Expected a string"));
 }
 /**
+* Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function object(value, message) {
+	if (!typeGuard.isObject(value)) throw new AssertionError(resolveAssertMessage(message, "Expected an object"));
+}
+/**
+* Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.
+*
+* @param value Value to narrow.
+* @param message Optional message or lazy message factory.
+*/
+function array(value, message) {
+	if (!typeGuard.isArray(value)) throw new AssertionError(resolveAssertMessage(message, "Expected an array"));
+}
+/**
 * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.
 *
 * @param value Value to narrow.

package/assert.js.map

@@ -1 +1 @@
-{"version":3,"file":"assert.js","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,QAAO,aAAa,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,UAAU,QAAQ,UAAU,CAC9B,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,CAAC,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,UAAU,OAAO,MAAM,CACzB,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,UAAU,YAAY,MAAM,CAC9B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SAC0B;AAC1B,KAAI,CAAC,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}
+{"version":3,"file":"assert.js","names":[],"sources":["../src/assert/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/assert\n *\n * ## Description\n *\n * Runtime **assertions** for invariants, narrowing, and exhaustiveness. Helpers throw\n * {@link AssertionError} with an optional message (`string` or {@link MaybeFn}) so failing fast stays\n * explicit without a heavy assertion library. Use `assert.ok`, `assert.string`, `assert.defined`,\n * `assert.fail`, and the rest on the namespace export from the package entry.\n *\n * ## Usage\n *\n * ```ts\n * import { assert } from \"yummies/assert\";\n *\n * assert.ok(user.id, \"user id is required\");\n * assert.defined(maybeName);\n * assert.string(raw);\n * ```\n */\n\nimport { callFunction } from 'yummies/common';\nimport { typeGuard } from 'yummies/type-guard';\nimport type { AnyObject, Maybe, MaybeFn } from 'yummies/types';\n\n/**\n * Error thrown by assertion helpers in this module.\n */\nexport class AssertionError extends Error {\n  override name = 'AssertionError';\n}\n\nfunction resolveAssertMessage(\n  message: MaybeFn<string> | undefined,\n  fallback: string,\n): string {\n  if (message === undefined) {\n    return fallback;\n  }\n  return callFunction(message);\n}\n\n/**\n * Throws when `condition` is falsy; narrows the type when it is truthy.\n *\n * @param condition Value treated as a boolean guard.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.ok(user.id, \"user id is required\");\n * ```\n */\nexport function ok(\n  condition: unknown,\n  message?: MaybeFn<string>,\n): asserts condition {\n  if (typeGuard.isFalsy(condition)) {\n    throw new AssertionError(resolveAssertMessage(message, 'Assertion failed'));\n  }\n}\n\n/**\n * Same as {@link ok}; common alias for internal invariants (e.g. after optional checks).\n */\nexport const invariant: typeof ok = ok;\n\n/**\n * Throws when the value is `null` or `undefined`; otherwise narrows away nullish.\n *\n * @param value Possibly nullish value.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.defined(maybeName, \"name must be present\");\n * ```\n */\nexport function defined<T>(\n  value: Maybe<T>,\n  message?: MaybeFn<string>,\n): asserts value is NonNullable<T> {\n  if (!typeGuard.isDefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `null`; allows `undefined` unless combined with other checks.\n *\n * @param value Value that may be `null`.\n * @param message Optional message or lazy message factory.\n */\nexport function notNull<T>(\n  value: T | null,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isNull(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a non-null value'),\n    );\n  }\n}\n\n/**\n * Throws when the value is `undefined`.\n *\n * @param value Value that may be `undefined`.\n * @param message Optional message or lazy message factory.\n */\nexport function notUndefined<T>(\n  value: T | undefined,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (typeGuard.isUndefined(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a defined value'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a string (primitive or `String` object); uses `typeGuard.isString`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function string(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is string {\n  if (!typeGuard.isString(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a string'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isObject`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function object<T extends AnyObject = AnyObject>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isObject(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an object'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a object (primitive or `AnyObject` object); uses `typeGuard.isArray`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function array<T extends any[] = any[]>(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!typeGuard.isArray(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected an array'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a finite non-NaN number; uses `typeGuard.isNumber`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function number(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is number {\n  if (!typeGuard.isNumber(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a finite number'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a boolean; uses `typeGuard.isBoolean`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function boolean(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is boolean {\n  if (!typeGuard.isBoolean(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a boolean'),\n    );\n  }\n}\n\n/**\n * Throws when `value` is not a symbol; uses `typeGuard.isSymbol`.\n *\n * @param value Value to narrow.\n * @param message Optional message or lazy message factory.\n */\nexport function symbol(\n  value: unknown,\n  message?: MaybeFn<string>,\n): asserts value is symbol {\n  if (!typeGuard.isSymbol(value)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, 'Expected a symbol'),\n    );\n  }\n}\n\n/**\n * Always throws; use for branches that must be impossible or as a typed “abort”.\n *\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * function parse(kind: \"a\" | \"b\") {\n *   if (kind === \"a\") return 1;\n *   if (kind === \"b\") return 2;\n *   assert.fail(\"unreachable\");\n * }\n * ```\n */\nexport function fail(message?: MaybeFn<string>): never {\n  throw new AssertionError(resolveAssertMessage(message, 'Unreachable'));\n}\n\n/**\n * Exhaustiveness helper: call with a `never` value when all union cases are handled.\n *\n * @param value Should be `never` when the type checker is satisfied.\n * @param message Optional message (this path always throws, so a lazy factory is unnecessary).\n */\nexport function unreachable(value: never, message?: string): never {\n  throw new AssertionError(\n    resolveAssertMessage(message, `Unexpected value: ${String(value)}`),\n  );\n}\n\n/**\n * Alias for {@link unreachable} (common name in switch exhaustiveness snippets).\n */\nexport { unreachable as never };\n\n/**\n * Throws when `value` is not an instance of `ctor`.\n *\n * @param value Value to check.\n * @param ctor Constructor used with `instanceof`.\n * @param message Optional message or lazy message factory.\n *\n * @example\n * ```ts\n * assert.instanceOf(el, HTMLElement, \"expected a DOM element\");\n * ```\n */\nexport function instanceOf<T>(\n  value: unknown,\n  ctor: abstract new (...args: never[]) => T,\n  message?: MaybeFn<string>,\n): asserts value is T {\n  if (!(value instanceof ctor)) {\n    throw new AssertionError(\n      resolveAssertMessage(message, `Expected instance of ${ctor.name}`),\n    );\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,IAAa,iBAAb,cAAoC,MAAM;CACxC,OAAgB;;AAGlB,SAAS,qBACP,SACA,UACQ;AACR,KAAI,YAAY,KAAA,EACd,QAAO;AAET,QAAO,aAAa,QAAQ;;;;;;;;;;;;;AAc9B,SAAgB,GACd,WACA,SACmB;AACnB,KAAI,UAAU,QAAQ,UAAU,CAC9B,OAAM,IAAI,eAAe,qBAAqB,SAAS,mBAAmB,CAAC;;;;;AAO/E,IAAa,YAAuB;;;;;;;;;;;;AAapC,SAAgB,QACd,OACA,SACiC;AACjC,KAAI,CAAC,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SACoB;AACpB,KAAI,UAAU,OAAO,MAAM,CACzB,OAAM,IAAI,eACR,qBAAqB,SAAS,4BAA4B,CAC3D;;;;;;;;AAUL,SAAgB,aACd,OACA,SACoB;AACpB,KAAI,UAAU,YAAY,MAAM,CAC9B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACoB;AACpB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,MACd,OACA,SACoB;AACpB,KAAI,CAAC,UAAU,QAAQ,MAAM,CAC3B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,2BAA2B,CAC1D;;;;;;;;AAUL,SAAgB,QACd,OACA,SAC0B;AAC1B,KAAI,CAAC,UAAU,UAAU,MAAM,CAC7B,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,CACpD;;;;;;;;AAUL,SAAgB,OACd,OACA,SACyB;AACzB,KAAI,CAAC,UAAU,SAAS,MAAM,CAC5B,OAAM,IAAI,eACR,qBAAqB,SAAS,oBAAoB,CACnD;;;;;;;;;;;;;;;;AAkBL,SAAgB,KAAK,SAAkC;AACrD,OAAM,IAAI,eAAe,qBAAqB,SAAS,cAAc,CAAC;;;;;;;;AASxE,SAAgB,YAAY,OAAc,SAAyB;AACjE,OAAM,IAAI,eACR,qBAAqB,SAAS,qBAAqB,OAAO,MAAM,GAAG,CACpE;;;;;;;;;;;;;;AAoBH,SAAgB,WACd,OACA,MACA,SACoB;AACpB,KAAI,EAAE,iBAAiB,MACrB,OAAM,IAAI,eACR,qBAAqB,SAAS,wBAAwB,KAAK,OAAO,CACnE"}

package/data.cjs

@@ -31,6 +31,19 @@ var isShallowEqual = (a, b) => {
 	return true;
 };
 /**
+* Checks whether an object has at least one enumerable key.
+*
+* @example
+* ```ts
+* hasEnumerableKeys({ id: 1 }); // true
+* hasEnumerableKeys({}); // false
+* ```
+*/
+var hasEnumerableKeys = (input) => {
+	for (const _key in input) return true;
+	return false;
+};
+/**
 * Wraps a value in an array when it is not already an array.
 *
 * @example
@@ -92,6 +105,7 @@ var UNSAFE_PROPERTY_KEYS = new Set([
 var isUnsafeProperty = (key) => UNSAFE_PROPERTY_KEYS.has(key);
 //#endregion
 exports.flatMapDeep = flatMapDeep;
+exports.hasEnumerableKeys = hasEnumerableKeys;
 exports.isShallowEqual = isShallowEqual;
 exports.isUnsafeProperty = isUnsafeProperty;
 exports.safeJsonParse = safeJsonParse;

package/data.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"data.cjs","names":[],"sources":["../src/data.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/data\n *\n * ## Description\n *\n * General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n *\n * ## Usage\n *\n * ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n */\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/**\n * Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n *\n * @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n */\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n  if (a === b) return true;\n\n  if (\n    typeof a !== 'object' ||\n    typeof b !== 'object' ||\n    a === null ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (a.constructor !== b.constructor) return false;\n\n  const isArrayA = Array.isArray(a);\n\n  if (isArrayA !== Array.isArray(b)) return false;\n\n  if (isArrayA) {\n    const arrA = a as unknown[];\n    const arrB = b as unknown[];\n    if (arrA.length !== arrB.length) return false;\n\n    for (const [i, element] of arrA.entries()) {\n      if (element !== arrB[i]) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n  if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n\n  if (aKeys.length !== bKeys.length) return false;\n\n  const bObj = b as AnyObject;\n  for (const key of aKeys) {\n    if (!Object.hasOwn(bObj, key) || (a as AnyObject)[key] !== bObj[key]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Wraps a value in an array when it is not already an array.\n *\n * @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n */\nexport const toArray = <TValue>(value: TValue | TValue[]): TValue[] => {\n  return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue | Array<DeepArray<TValue>>;\n\n/**\n * Recursively flattens a nested array and maps the collected values.\n *\n * @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n */\nexport const flatMapDeep = <TSource, TNewValue>(\n  arr: DeepArray<TSource>,\n  fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n  const source: TSource[] = [];\n\n  const collect = (value: DeepArray<TSource>): void => {\n    if (!Array.isArray(value)) {\n      source.push(value);\n      return;\n    }\n\n    for (const item of value) {\n      collect(item);\n    }\n  };\n\n  collect(arr);\n\n  return source.map((value, i) => fn(value, i, source));\n};\n\n/**\n * Parses JSON safely and returns a fallback value when parsing fails.\n *\n * @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n */\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n  json: Maybe<string>,\n  fallback: TFallback = null as TFallback,\n): TValue | TFallback => {\n  if (json == null) return fallback;\n\n  try {\n    return JSON.parse(json);\n  } catch {\n    return fallback;\n  }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/**\n * Checks whether a property key is unsafe and can lead to prototype pollution.\n *\n * @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}
+{"version":3,"file":"data.cjs","names":[],"sources":["../src/data.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/data\n *\n * ## Description\n *\n * General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n *\n * ## Usage\n *\n * ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n */\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/**\n * Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n *\n * @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n */\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n  if (a === b) return true;\n\n  if (\n    typeof a !== 'object' ||\n    typeof b !== 'object' ||\n    a === null ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (a.constructor !== b.constructor) return false;\n\n  const isArrayA = Array.isArray(a);\n\n  if (isArrayA !== Array.isArray(b)) return false;\n\n  if (isArrayA) {\n    const arrA = a as unknown[];\n    const arrB = b as unknown[];\n    if (arrA.length !== arrB.length) return false;\n\n    for (const [i, element] of arrA.entries()) {\n      if (element !== arrB[i]) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n  if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n\n  if (aKeys.length !== bKeys.length) return false;\n\n  const bObj = b as AnyObject;\n  for (const key of aKeys) {\n    if (!Object.hasOwn(bObj, key) || (a as AnyObject)[key] !== bObj[key]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Checks whether an object has at least one enumerable key.\n *\n * @example\n * ```ts\n * hasEnumerableKeys({ id: 1 }); // true\n * hasEnumerableKeys({}); // false\n * ```\n */\nexport const hasEnumerableKeys = (input: AnyObject): boolean => {\n  for (const _key in input) {\n    return true;\n  }\n  return false;\n};\n\n/**\n * Wraps a value in an array when it is not already an array.\n *\n * @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n */\nexport const toArray = <TValue>(value: TValue | TValue[]): TValue[] => {\n  return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue | Array<DeepArray<TValue>>;\n\n/**\n * Recursively flattens a nested array and maps the collected values.\n *\n * @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n */\nexport const flatMapDeep = <TSource, TNewValue>(\n  arr: DeepArray<TSource>,\n  fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n  const source: TSource[] = [];\n\n  const collect = (value: DeepArray<TSource>): void => {\n    if (!Array.isArray(value)) {\n      source.push(value);\n      return;\n    }\n\n    for (const item of value) {\n      collect(item);\n    }\n  };\n\n  collect(arr);\n\n  return source.map((value, i) => fn(value, i, source));\n};\n\n/**\n * Parses JSON safely and returns a fallback value when parsing fails.\n *\n * @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n */\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n  json: Maybe<string>,\n  fallback: TFallback = null as TFallback,\n): TValue | TFallback => {\n  if (json == null) return fallback;\n\n  try {\n    return JSON.parse(json);\n  } catch {\n    return fallback;\n  }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/**\n * Checks whether a property key is unsafe and can lead to prototype pollution.\n *\n * @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;;AAYT,IAAa,qBAAqB,UAA8B;AAC9D,MAAK,MAAM,QAAQ,MACjB,QAAO;AAET,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}

package/data.d.ts

@@ -1,4 +1,4 @@
-import { Maybe } from 'yummies/types';
+import { AnyObject, Maybe } from 'yummies/types';
 
 /**
  * ---header-docs-section---
@@ -27,6 +27,16 @@ import { Maybe } from 'yummies/types';
  * ```
  */
 declare const isShallowEqual: (a: unknown, b: unknown) => boolean;
+/**
+ * Checks whether an object has at least one enumerable key.
+ *
+ * @example
+ * ```ts
+ * hasEnumerableKeys({ id: 1 }); // true
+ * hasEnumerableKeys({}); // false
+ * ```
+ */
+declare const hasEnumerableKeys: (input: AnyObject) => boolean;
 /**
  * Wraps a value in an array when it is not already an array.
  *
@@ -64,4 +74,4 @@ declare const safeJsonParse: <TValue = any, TFallback = null>(json: Maybe<string
  */
 declare const isUnsafeProperty: (key: any) => boolean;
 
-export { flatMapDeep, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };
+export { flatMapDeep, hasEnumerableKeys, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };

package/data.js

@@ -30,6 +30,19 @@ var isShallowEqual = (a, b) => {
 	return true;
 };
 /**
+* Checks whether an object has at least one enumerable key.
+*
+* @example
+* ```ts
+* hasEnumerableKeys({ id: 1 }); // true
+* hasEnumerableKeys({}); // false
+* ```
+*/
+var hasEnumerableKeys = (input) => {
+	for (const _key in input) return true;
+	return false;
+};
+/**
 * Wraps a value in an array when it is not already an array.
 *
 * @example
@@ -90,6 +103,6 @@ var UNSAFE_PROPERTY_KEYS = new Set([
 */
 var isUnsafeProperty = (key) => UNSAFE_PROPERTY_KEYS.has(key);
 //#endregion
-export { flatMapDeep, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };
+export { flatMapDeep, hasEnumerableKeys, isShallowEqual, isUnsafeProperty, safeJsonParse, toArray };
 
 //# sourceMappingURL=data.js.map

package/data.js.map

@@ -1 +1 @@
-{"version":3,"file":"data.js","names":[],"sources":["../src/data.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/data\n *\n * ## Description\n *\n * General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n *\n * ## Usage\n *\n * ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n */\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/**\n * Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n *\n * @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n */\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n  if (a === b) return true;\n\n  if (\n    typeof a !== 'object' ||\n    typeof b !== 'object' ||\n    a === null ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (a.constructor !== b.constructor) return false;\n\n  const isArrayA = Array.isArray(a);\n\n  if (isArrayA !== Array.isArray(b)) return false;\n\n  if (isArrayA) {\n    const arrA = a as unknown[];\n    const arrB = b as unknown[];\n    if (arrA.length !== arrB.length) return false;\n\n    for (const [i, element] of arrA.entries()) {\n      if (element !== arrB[i]) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n  if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n\n  if (aKeys.length !== bKeys.length) return false;\n\n  const bObj = b as AnyObject;\n  for (const key of aKeys) {\n    if (!Object.hasOwn(bObj, key) || (a as AnyObject)[key] !== bObj[key]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Wraps a value in an array when it is not already an array.\n *\n * @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n */\nexport const toArray = <TValue>(value: TValue | TValue[]): TValue[] => {\n  return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue | Array<DeepArray<TValue>>;\n\n/**\n * Recursively flattens a nested array and maps the collected values.\n *\n * @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n */\nexport const flatMapDeep = <TSource, TNewValue>(\n  arr: DeepArray<TSource>,\n  fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n  const source: TSource[] = [];\n\n  const collect = (value: DeepArray<TSource>): void => {\n    if (!Array.isArray(value)) {\n      source.push(value);\n      return;\n    }\n\n    for (const item of value) {\n      collect(item);\n    }\n  };\n\n  collect(arr);\n\n  return source.map((value, i) => fn(value, i, source));\n};\n\n/**\n * Parses JSON safely and returns a fallback value when parsing fails.\n *\n * @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n */\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n  json: Maybe<string>,\n  fallback: TFallback = null as TFallback,\n): TValue | TFallback => {\n  if (json == null) return fallback;\n\n  try {\n    return JSON.parse(json);\n  } catch {\n    return fallback;\n  }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/**\n * Checks whether a property key is unsafe and can lead to prototype pollution.\n *\n * @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}
+{"version":3,"file":"data.js","names":[],"sources":["../src/data.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/data\n *\n * ## Description\n *\n * General-purpose data helpers: shallow equality, normalizing values to arrays, and recursive\n * `flatMap`-style transforms. They complement `Array`/`Object` builtins when you need stable\n * comparisons for memoization or small structural utilities without pulling a large lodash-style\n * dependency into the bundle.\n *\n * ## Usage\n *\n * ```ts\n * import { isShallowEqual, toArray } from \"yummies/data\";\n * ```\n */\n\nimport type { AnyObject, Maybe } from 'yummies/types';\n\n/**\n * Performs a shallow comparison for arrays, plain objects, dates and regular expressions.\n *\n * @example\n * ```ts\n * isShallowEqual({ id: 1 }, { id: 1 }); // true\n * ```\n */\nexport const isShallowEqual = (a: unknown, b: unknown): boolean => {\n  if (a === b) return true;\n\n  if (\n    typeof a !== 'object' ||\n    typeof b !== 'object' ||\n    a === null ||\n    b === null\n  ) {\n    return false;\n  }\n\n  if (a.constructor !== b.constructor) return false;\n\n  const isArrayA = Array.isArray(a);\n\n  if (isArrayA !== Array.isArray(b)) return false;\n\n  if (isArrayA) {\n    const arrA = a as unknown[];\n    const arrB = b as unknown[];\n    if (arrA.length !== arrB.length) return false;\n\n    for (const [i, element] of arrA.entries()) {\n      if (element !== arrB[i]) return false;\n    }\n    return true;\n  }\n\n  if (a instanceof Date) return a.getTime() === (b as Date).getTime();\n\n  if (a instanceof RegExp) return a.toString() === (b as RegExp).toString();\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n\n  if (aKeys.length !== bKeys.length) return false;\n\n  const bObj = b as AnyObject;\n  for (const key of aKeys) {\n    if (!Object.hasOwn(bObj, key) || (a as AnyObject)[key] !== bObj[key]) {\n      return false;\n    }\n  }\n\n  return true;\n};\n\n/**\n * Checks whether an object has at least one enumerable key.\n *\n * @example\n * ```ts\n * hasEnumerableKeys({ id: 1 }); // true\n * hasEnumerableKeys({}); // false\n * ```\n */\nexport const hasEnumerableKeys = (input: AnyObject): boolean => {\n  for (const _key in input) {\n    return true;\n  }\n  return false;\n};\n\n/**\n * Wraps a value in an array when it is not already an array.\n *\n * @example\n * ```ts\n * toArray('item'); // ['item']\n * ```\n */\nexport const toArray = <TValue>(value: TValue | TValue[]): TValue[] => {\n  return Array.isArray(value) ? value : [value];\n};\n\ntype DeepArray<TValue> = TValue | Array<DeepArray<TValue>>;\n\n/**\n * Recursively flattens a nested array and maps the collected values.\n *\n * @example\n * ```ts\n * flatMapDeep([1, [2, [3]]], (value) => value * 2); // [2, 4, 6]\n * ```\n */\nexport const flatMapDeep = <TSource, TNewValue>(\n  arr: DeepArray<TSource>,\n  fn: (value: TSource, i: number, arr: TSource[]) => TNewValue,\n): TNewValue[] => {\n  const source: TSource[] = [];\n\n  const collect = (value: DeepArray<TSource>): void => {\n    if (!Array.isArray(value)) {\n      source.push(value);\n      return;\n    }\n\n    for (const item of value) {\n      collect(item);\n    }\n  };\n\n  collect(arr);\n\n  return source.map((value, i) => fn(value, i, source));\n};\n\n/**\n * Parses JSON safely and returns a fallback value when parsing fails.\n *\n * @example\n * ```ts\n * safeJsonParse('{\"enabled\":true}', {}); // { enabled: true }\n * ```\n */\nexport const safeJsonParse = <TValue = any, TFallback = null>(\n  json: Maybe<string>,\n  fallback: TFallback = null as TFallback,\n): TValue | TFallback => {\n  if (json == null) return fallback;\n\n  try {\n    return JSON.parse(json);\n  } catch {\n    return fallback;\n  }\n};\n\nconst UNSAFE_PROPERTY_KEYS = new Set(['__proto__', 'prototype', 'constructor']);\n\n/**\n * Checks whether a property key is unsafe and can lead to prototype pollution.\n *\n * @example\n * isUnsafeProperty('__proto__'); // true\n * isUnsafeProperty('name'); // false\n */\nexport const isUnsafeProperty = (key: any) => UNSAFE_PROPERTY_KEYS.has(key);\n"],"mappings":";;;;;;;;;AA4BA,IAAa,kBAAkB,GAAY,MAAwB;AACjE,KAAI,MAAM,EAAG,QAAO;AAEpB,KACE,OAAO,MAAM,YACb,OAAO,MAAM,YACb,MAAM,QACN,MAAM,KAEN,QAAO;AAGT,KAAI,EAAE,gBAAgB,EAAE,YAAa,QAAO;CAE5C,MAAM,WAAW,MAAM,QAAQ,EAAE;AAEjC,KAAI,aAAa,MAAM,QAAQ,EAAE,CAAE,QAAO;AAE1C,KAAI,UAAU;EACZ,MAAM,OAAO;EACb,MAAM,OAAO;AACb,MAAI,KAAK,WAAW,KAAK,OAAQ,QAAO;AAExC,OAAK,MAAM,CAAC,GAAG,YAAY,KAAK,SAAS,CACvC,KAAI,YAAY,KAAK,GAAI,QAAO;AAElC,SAAO;;AAGT,KAAI,aAAa,KAAM,QAAO,EAAE,SAAS,KAAM,EAAW,SAAS;AAEnE,KAAI,aAAa,OAAQ,QAAO,EAAE,UAAU,KAAM,EAAa,UAAU;CAEzE,MAAM,QAAQ,OAAO,KAAK,EAAE;CAC5B,MAAM,QAAQ,OAAO,KAAK,EAAE;AAE5B,KAAI,MAAM,WAAW,MAAM,OAAQ,QAAO;CAE1C,MAAM,OAAO;AACb,MAAK,MAAM,OAAO,MAChB,KAAI,CAAC,OAAO,OAAO,MAAM,IAAI,IAAK,EAAgB,SAAS,KAAK,KAC9D,QAAO;AAIX,QAAO;;;;;;;;;;;AAYT,IAAa,qBAAqB,UAA8B;AAC9D,MAAK,MAAM,QAAQ,MACjB,QAAO;AAET,QAAO;;;;;;;;;;AAWT,IAAa,WAAmB,UAAuC;AACrE,QAAO,MAAM,QAAQ,MAAM,GAAG,QAAQ,CAAC,MAAM;;;;;;;;;;AAa/C,IAAa,eACX,KACA,OACgB;CAChB,MAAM,SAAoB,EAAE;CAE5B,MAAM,WAAW,UAAoC;AACnD,MAAI,CAAC,MAAM,QAAQ,MAAM,EAAE;AACzB,UAAO,KAAK,MAAM;AAClB;;AAGF,OAAK,MAAM,QAAQ,MACjB,SAAQ,KAAK;;AAIjB,SAAQ,IAAI;AAEZ,QAAO,OAAO,KAAK,OAAO,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;;;;;;;;;;AAWvD,IAAa,iBACX,MACA,WAAsB,SACC;AACvB,KAAI,QAAQ,KAAM,QAAO;AAEzB,KAAI;AACF,SAAO,KAAK,MAAM,KAAK;SACjB;AACN,SAAO;;;AAIX,IAAM,uBAAuB,IAAI,IAAI;CAAC;CAAa;CAAa;CAAc,CAAC;;;;;;;;AAS/E,IAAa,oBAAoB,QAAa,qBAAqB,IAAI,IAAI"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "yummies",
-  "version": "7.16.2",
+  "version": "7.18.0",
   "keywords": [
     "javascript",
     "typescript",