yummies 7.19.4 → 7.20.1

package/type-guard.js.map

@@ -1 +1 @@
-{"version":3,"file":"type-guard.js","names":[],"sources":["../src/type-guard/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/type-guard\n *\n * ## Description\n *\n * Runtime **type guards** and narrowers for primitives, DOM nodes, `NaN`, and common app values.\n * Each helper is implemented once with consistent `typeof` / `Object.prototype.toString` logic so\n * `unknown` from JSON, events, or third-party scripts becomes safe typed branches without ad-hoc\n * checks scattered through the codebase.\n *\n * ## Usage\n *\n * ```ts\n * import { typeGuard } from \"yummies/type-guard\";\n * ```\n */\n\nimport type {\n  AnyFunction,\n  AnyObject,\n  FalsyValues,\n  ValueOf,\n} from 'yummies/types';\n\nconst TYPE = {\n  Null: 'null',\n  Undefined: 'undefined',\n  NaN: 'nan',\n  Object: '[object Object]',\n  Array: '[object Array]',\n  String: '[object String]',\n  Number: '[object Number]',\n  Boolean: '[object Boolean]',\n  Function: '[object Function]',\n  AsyncFunction: '[object AsyncFunction]',\n  RegExp: '[object RegExp]',\n  Symbol: '[object Symbol]',\n  Infinite: 'infinite',\n  Element: 'element',\n};\n\ntype Type = ValueOf<typeof TYPE>;\n\nfunction getType(value: unknown): Type {\n  if (value === undefined) {\n    return TYPE.Undefined;\n  }\n  if (value === null) {\n    return TYPE.Null;\n  }\n\n  // handle DOM elements\n  // @ts-expect-error\n  if (value && (value.nodeType === 1 || value.nodeType === 9)) {\n    return TYPE.Element;\n  }\n\n  const stringifiedValue = Object.prototype.toString.call(value);\n\n  // handle NaN and Infinity\n  if (stringifiedValue === TYPE.Number) {\n    if (Number.isNaN(value as number)) {\n      return TYPE.NaN;\n    }\n    if (!Number.isFinite(value as number)) {\n      return TYPE.Infinite;\n    }\n  }\n\n  return stringifiedValue as Type;\n}\n\nconst createTypeGuard =\n  <T>(...types: Type[]) =>\n  (value: unknown): value is T =>\n    types.includes(getType(value));\n\n/**\n * Checks that a value is neither `null` nor `undefined`.\n *\n * @template T Value type without nullish branches.\n * @param value Value to test.\n * @returns `true` when the value is defined.\n *\n * @example\n * ```ts\n * isDefined(0); // true\n * ```\n *\n * @example\n * ```ts\n * isDefined(null); // false\n * ```\n */\nexport const isDefined = <T>(value: T | undefined | null): value is T =>\n  value != null;\n\n/**\n * Checks whether a value is truthy (`!!value`).\n *\n * @param value Value to test.\n * @returns `true` when `!!value` is true.\n *\n * @example\n * ```ts\n * isTruthy(1); // true\n * ```\n *\n * @example\n * ```ts\n * isTruthy(0); // false\n * ```\n */\nexport const isTruthy = <T>(value: T): value is Exclude<T, FalsyValues> =>\n  !!value;\n\n/**\n * Checks whether a value is falsy (`!Boolean(value)`).\n *\n * @param value Value to test.\n * @returns `true` when `Boolean(value)` is false.\n *\n * @example\n * ```ts\n * isFalsy(null); // true\n * ```\n *\n * @example\n * ```ts\n * isFalsy(\"x\"); // false\n * ```\n */\nexport const isFalsy = <T>(value: T): value is Extract<T, FalsyValues> =>\n  !value;\n\n/**\n * Checks whether a value is exactly `null`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * ```\n *\n * @example\n * ```ts\n * isNull(undefined); // false\n * ```\n */\nexport const isNull = createTypeGuard<null>(TYPE.Null);\n\n/**\n * Checks whether a value is exactly `undefined`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * ```\n *\n * @example\n * ```ts\n * isUndefined('value'); // false\n * ```\n */\nexport const isUndefined = createTypeGuard<undefined>(TYPE.Undefined);\n\n/**\n * Checks whether a value is a plain object.\n *\n * @param value Value to test.\n * @returns `true` when the value matches `[object Object]`.\n *\n * @example\n * ```ts\n * isObject({ id: 1 }); // true\n * ```\n *\n * @example\n * ```ts\n * isObject([]); // false\n * ```\n */\nexport const isObject = createTypeGuard<AnyObject>(TYPE.Object);\n\n/**\n * Checks whether a value is an array.\n *\n * @param value Value to test.\n * @returns `true` when the value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]); // true\n * ```\n *\n * @example\n * ```ts\n * isArray({ length: 1 }); // false\n * ```\n */\nexport const isArray = createTypeGuard<unknown[]>(TYPE.Array);\n\n/**\n * Checks whether a value is a string object or primitive string.\n *\n * @param value Value to test.\n * @returns `true` when the value is a string.\n *\n * @example\n * ```ts\n * isString('hello'); // true\n * ```\n *\n * @example\n * ```ts\n * isString(123); // false\n * ```\n */\nexport const isString = createTypeGuard<string>(TYPE.String);\n\n/**\n * Checks whether a value is a finite number.\n *\n * Unlike `isNaN` and `isInfinite`, this guard only matches regular numeric values.\n *\n * @param value Value to test.\n * @returns `true` when the value is a non-NaN finite number.\n *\n * @example\n * ```ts\n * isNumber(123); // true\n * ```\n *\n * @example\n * ```ts\n * isNumber(Number.NaN); // false\n * ```\n */\nexport const isNumber = createTypeGuard<number>(TYPE.Number);\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value Value to test.\n * @returns `true` when the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * ```\n *\n * @example\n * ```ts\n * isBoolean('true'); // false\n * ```\n */\nexport const isBoolean = createTypeGuard<boolean>(TYPE.Boolean);\n\n/**\n * Checks whether a value is a synchronous or asynchronous function.\n *\n * @param value Value to test.\n * @returns `true` when the value is a function.\n *\n * @example\n * ```ts\n * isFunction(() => {}); // true\n * ```\n *\n * @example\n * ```ts\n * isFunction(async () => {}); // true\n * ```\n */\nexport const isFunction = createTypeGuard<AnyFunction>(\n  TYPE.Function,\n  TYPE.AsyncFunction,\n);\n\n/**\n * Checks whether a value is a regular expression.\n *\n * @param value Value to test.\n * @returns `true` when the value is a `RegExp`.\n *\n * @example\n * ```ts\n * isRegExp(/foo/); // true\n * ```\n *\n * @example\n * ```ts\n * isRegExp('foo'); // false\n * ```\n */\nexport const isRegExp = createTypeGuard<RegExp>(TYPE.RegExp);\n\n/**\n * Checks whether a value looks like a DOM element or document node.\n *\n * @param value Value to test.\n * @returns `true` when the value has an element-like node type.\n *\n * @example\n * ```ts\n * isElement(document.body); // true\n * ```\n *\n * @example\n * ```ts\n * isElement({ nodeType: 3 }); // false\n * ```\n */\nexport const isElement = createTypeGuard<HTMLElement>(TYPE.Element);\n\n/**\n * Checks whether a value is `NaN`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `NaN`.\n *\n * @example\n * ```ts\n * isNaN(Number.NaN); // true\n * ```\n *\n * @example\n * ```ts\n * isNaN(5); // false\n * ```\n */\nexport const isNaN = createTypeGuard<number>(TYPE.NaN) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is positive or negative infinity.\n *\n * @param value Value to test.\n * @returns `true` when the value is not finite.\n *\n * @example\n * ```ts\n * isInfinite(Infinity); // true\n * ```\n *\n * @example\n * ```ts\n * isInfinite(10); // false\n * ```\n */\nexport const isInfinite = createTypeGuard<number>(TYPE.Infinite) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is a symbol.\n *\n * @param value Value to test.\n * @returns `true` when the value is a symbol.\n *\n * @example\n * ```ts\n * isSymbol(Symbol('id')); // true\n * ```\n *\n * @example\n * ```ts\n * isSymbol('id'); // false\n * ```\n */\nexport const isSymbol = createTypeGuard<symbol>(TYPE.Symbol);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAyBA,IAAM,OAAO;CACX,MAAM;CACN,WAAW;CACX,KAAK;CACL,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,UAAU;CACV,eAAe;CACf,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;CACV;AAID,SAAS,QAAQ,OAAsB;AACrC,KAAI,UAAU,KAAA,EACZ,QAAO,KAAK;AAEd,KAAI,UAAU,KACZ,QAAO,KAAK;AAKd,KAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,GACvD,QAAO,KAAK;CAGd,MAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,MAAM;AAG9D,KAAI,qBAAqB,KAAK,QAAQ;AACpC,MAAI,OAAO,MAAM,MAAgB,CAC/B,QAAO,KAAK;AAEd,MAAI,CAAC,OAAO,SAAS,MAAgB,CACnC,QAAO,KAAK;;AAIhB,QAAO;;AAGT,IAAM,mBACA,GAAG,WACN,UACC,MAAM,SAAS,QAAQ,MAAM,CAAC;;;;;;;;;;;;;;;;;;AAmBlC,IAAa,aAAgB,UAC3B,SAAS;;;;;;;;;;;;;;;;;AAkBX,IAAa,YAAe,UAC1B,CAAC,CAAC;;;;;;;;;;;;;;;;;AAkBJ,IAAa,WAAc,UACzB,CAAC;;;;;;;;;;;;;;;;;AAkBH,IAAa,SAAS,gBAAsB,KAAK,KAAK;;;;;;;;;;;;;;;;;AAkBtD,IAAa,cAAc,gBAA2B,KAAK,UAAU;;;;;;;;;;;;;;;;;AAkBrE,IAAa,WAAW,gBAA2B,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB/D,IAAa,UAAU,gBAA2B,KAAK,MAAM;;;;;;;;;;;;;;;;;AAkB7D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;;;AAoB5D,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAAyB,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkB/D,IAAa,aAAa,gBACxB,KAAK,UACL,KAAK,cACN;;;;;;;;;;;;;;;;;AAkBD,IAAa,WAAW,gBAAwB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB5D,IAAa,YAAY,gBAA6B,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAkBnE,IAAa,QAAQ,gBAAwB,KAAK,IAAI;;;;;;;;;;;;;;;;;AAoBtD,IAAa,aAAa,gBAAwB,KAAK,SAAS;;;;;;;;;;;;;;;;;AAoBhE,IAAa,WAAW,gBAAwB,KAAK,OAAO"}
+{"version":3,"file":"type-guard.js","names":[],"sources":["../src/type-guard/_exports.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/type-guard\n *\n * ## Description\n *\n * Runtime **type guards** and narrowers for primitives, DOM nodes, `NaN`, and common app values.\n * Each helper is implemented once with consistent `typeof` / `Object.prototype.toString` logic so\n * `unknown` from JSON, events, or third-party scripts becomes safe typed branches without ad-hoc\n * checks scattered through the codebase.\n *\n * ## Usage\n *\n * ```ts\n * import { typeGuard } from \"yummies/type-guard\";\n * ```\n */\n\nimport type {\n  AnyFunction,\n  AnyObject,\n  FalsyValues,\n  ValueOf,\n} from 'yummies/types';\n\nconst TYPE = {\n  Null: 'null',\n  Undefined: 'undefined',\n  NaN: 'nan',\n  Object: '[object Object]',\n  Array: '[object Array]',\n  String: '[object String]',\n  Number: '[object Number]',\n  Boolean: '[object Boolean]',\n  Function: '[object Function]',\n  AsyncFunction: '[object AsyncFunction]',\n  RegExp: '[object RegExp]',\n  Symbol: '[object Symbol]',\n  Infinite: 'infinite',\n  Element: 'element',\n};\n\ntype Type = ValueOf<typeof TYPE>;\n\nfunction getType(value: unknown): Type {\n  if (value === undefined) {\n    return TYPE.Undefined;\n  }\n  if (value === null) {\n    return TYPE.Null;\n  }\n\n  // handle DOM elements\n  // @ts-expect-error\n  if (value && (value.nodeType === 1 || value.nodeType === 9)) {\n    return TYPE.Element;\n  }\n\n  const stringifiedValue = Object.prototype.toString.call(value);\n\n  // handle NaN and Infinity\n  if (stringifiedValue === TYPE.Number) {\n    if (Number.isNaN(value as number)) {\n      return TYPE.NaN;\n    }\n    if (!Number.isFinite(value as number)) {\n      return TYPE.Infinite;\n    }\n  }\n\n  return stringifiedValue as Type;\n}\n\nconst createTypeGuard =\n  <T>(...types: Type[]) =>\n  (value: unknown): value is T =>\n    types.includes(getType(value));\n\n/**\n * Checks that a value is neither `null` nor `undefined`.\n *\n * @template T Value type without nullish branches.\n * @param value Value to test.\n * @returns `true` when the value is defined.\n *\n * @example\n * ```ts\n * isDefined(0); // true\n * ```\n *\n * @example\n * ```ts\n * isDefined(null); // false\n * ```\n */\nexport const isDefined = <T>(value: T | undefined | null): value is T =>\n  value != null;\n\n/**\n * Checks whether a value is truthy (`!!value`).\n *\n * @param value Value to test.\n * @returns `true` when `!!value` is true.\n *\n * @example\n * ```ts\n * isTruthy(1); // true\n * ```\n *\n * @example\n * ```ts\n * isTruthy(0); // false\n * ```\n */\nexport const isTruthy = <T>(value: T): value is Exclude<T, FalsyValues> =>\n  !!value;\n\n/**\n * Checks whether a value is falsy (`!Boolean(value)`).\n *\n * @param value Value to test.\n * @returns `true` when `Boolean(value)` is false.\n *\n * @example\n * ```ts\n * isFalsy(null); // true\n * ```\n *\n * @example\n * ```ts\n * isFalsy(\"x\"); // false\n * ```\n */\nexport const isFalsy = <T>(value: T): value is Extract<T, FalsyValues> =>\n  !value;\n\n/**\n * Checks whether a value is exactly `null`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `null`.\n *\n * @example\n * ```ts\n * isNull(null); // true\n * ```\n *\n * @example\n * ```ts\n * isNull(undefined); // false\n * ```\n */\nexport const isNull = createTypeGuard<null>(TYPE.Null);\n\n/**\n * Checks whether a value is exactly `undefined`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `undefined`.\n *\n * @example\n * ```ts\n * isUndefined(undefined); // true\n * ```\n *\n * @example\n * ```ts\n * isUndefined('value'); // false\n * ```\n */\nexport const isUndefined = createTypeGuard<undefined>(TYPE.Undefined);\n\n/**\n * Checks whether a value is a plain object.\n *\n * @param value Value to test.\n * @returns `true` when the value matches `[object Object]`.\n *\n * @example\n * ```ts\n * isObject({ id: 1 }); // true\n * ```\n *\n * @example\n * ```ts\n * isObject([]); // false\n * ```\n */\nexport const isObject = createTypeGuard<AnyObject>(TYPE.Object);\n\n/**\n * Checks whether a value is object-like: non-null and `typeof value === 'object'`.\n *\n * This includes plain objects, arrays, `Date`, `RegExp`, boxed primitives, and other built-ins\n * whose `typeof` is `\"object\"`. It is broader than `isObject`, which only matches plain objects.\n *\n * @template T Input value type.\n * @param value Value to test.\n * @returns `true` when the value is a non-null object.\n *\n * @example\n * ```ts\n * isObjectLike({ a: 1 }); // true\n * ```\n *\n * @example\n * ```ts\n * isObjectLike([]); // true\n * ```\n *\n * @example\n * ```ts\n * isObjectLike(new Date()); // true\n * ```\n *\n * @example\n * ```ts\n * isObjectLike(null); // false\n * ```\n *\n * @example\n * ```ts\n * isObjectLike(() => {}); // false\n * ```\n */\nexport const isObjectLike = <T = never>(\n  value: unknown,\n): value is T extends never ? Extract<typeof value, object> : T =>\n  typeof value === 'object' && !!value;\n\n/**\n * Checks whether a value is an array.\n *\n * @param value Value to test.\n * @returns `true` when the value is an array.\n *\n * @example\n * ```ts\n * isArray([1, 2, 3]); // true\n * ```\n *\n * @example\n * ```ts\n * isArray({ length: 1 }); // false\n * ```\n */\nexport const isArray = createTypeGuard<unknown[]>(TYPE.Array);\n\n/**\n * Checks whether a value is a string object or primitive string.\n *\n * @param value Value to test.\n * @returns `true` when the value is a string.\n *\n * @example\n * ```ts\n * isString('hello'); // true\n * ```\n *\n * @example\n * ```ts\n * isString(123); // false\n * ```\n */\nexport const isString = createTypeGuard<string>(TYPE.String);\n\n/**\n * Checks whether a value is a finite number.\n *\n * Unlike `isNaN` and `isInfinite`, this guard only matches regular numeric values.\n *\n * @param value Value to test.\n * @returns `true` when the value is a non-NaN finite number.\n *\n * @example\n * ```ts\n * isNumber(123); // true\n * ```\n *\n * @example\n * ```ts\n * isNumber(Number.NaN); // false\n * ```\n */\nexport const isNumber = createTypeGuard<number>(TYPE.Number);\n\n/**\n * Checks whether a value is a boolean.\n *\n * @param value Value to test.\n * @returns `true` when the value is a boolean.\n *\n * @example\n * ```ts\n * isBoolean(true); // true\n * ```\n *\n * @example\n * ```ts\n * isBoolean('true'); // false\n * ```\n */\nexport const isBoolean = createTypeGuard<boolean>(TYPE.Boolean);\n\n/**\n * Checks whether a value is a synchronous or asynchronous function.\n *\n * @param value Value to test.\n * @returns `true` when the value is a function.\n *\n * @example\n * ```ts\n * isFunction(() => {}); // true\n * ```\n *\n * @example\n * ```ts\n * isFunction(async () => {}); // true\n * ```\n */\nexport const isFunction = createTypeGuard<AnyFunction>(\n  TYPE.Function,\n  TYPE.AsyncFunction,\n);\n\n/**\n * Checks whether a value is a regular expression.\n *\n * @param value Value to test.\n * @returns `true` when the value is a `RegExp`.\n *\n * @example\n * ```ts\n * isRegExp(/foo/); // true\n * ```\n *\n * @example\n * ```ts\n * isRegExp('foo'); // false\n * ```\n */\nexport const isRegExp = createTypeGuard<RegExp>(TYPE.RegExp);\n\n/**\n * Checks whether a value looks like a DOM element or document node.\n *\n * @param value Value to test.\n * @returns `true` when the value has an element-like node type.\n *\n * @example\n * ```ts\n * isElement(document.body); // true\n * ```\n *\n * @example\n * ```ts\n * isElement({ nodeType: 3 }); // false\n * ```\n */\nexport const isElement = createTypeGuard<HTMLElement>(TYPE.Element);\n\n/**\n * Checks whether a value is `NaN`.\n *\n * @param value Value to test.\n * @returns `true` when the value is `NaN`.\n *\n * @example\n * ```ts\n * isNaN(Number.NaN); // true\n * ```\n *\n * @example\n * ```ts\n * isNaN(5); // false\n * ```\n */\nexport const isNaN = createTypeGuard<number>(TYPE.NaN) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is positive or negative infinity.\n *\n * @param value Value to test.\n * @returns `true` when the value is not finite.\n *\n * @example\n * ```ts\n * isInfinite(Infinity); // true\n * ```\n *\n * @example\n * ```ts\n * isInfinite(10); // false\n * ```\n */\nexport const isInfinite = createTypeGuard<number>(TYPE.Infinite) as (\n  value: unknown,\n) => boolean;\n\n/**\n * Checks whether a value is a symbol.\n *\n * @param value Value to test.\n * @returns `true` when the value is a symbol.\n *\n * @example\n * ```ts\n * isSymbol(Symbol('id')); // true\n * ```\n *\n * @example\n * ```ts\n * isSymbol('id'); // false\n * ```\n */\nexport const isSymbol = createTypeGuard<symbol>(TYPE.Symbol);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAyBA,IAAM,OAAO;CACX,MAAM;CACN,WAAW;CACX,KAAK;CACL,QAAQ;CACR,OAAO;CACP,QAAQ;CACR,QAAQ;CACR,SAAS;CACT,UAAU;CACV,eAAe;CACf,QAAQ;CACR,QAAQ;CACR,UAAU;CACV,SAAS;AACX;AAIA,SAAS,QAAQ,OAAsB;CACrC,IAAI,UAAU,KAAA,GACZ,OAAO,KAAK;CAEd,IAAI,UAAU,MACZ,OAAO,KAAK;CAKd,IAAI,UAAU,MAAM,aAAa,KAAK,MAAM,aAAa,IACvD,OAAO,KAAK;CAGd,MAAM,mBAAmB,OAAO,UAAU,SAAS,KAAK,KAAK;CAG7D,IAAI,qBAAqB,KAAK,QAAQ;EACpC,IAAI,OAAO,MAAM,KAAe,GAC9B,OAAO,KAAK;EAEd,IAAI,CAAC,OAAO,SAAS,KAAe,GAClC,OAAO,KAAK;CAEhB;CAEA,OAAO;AACT;AAEA,IAAM,mBACA,GAAG,WACN,UACC,MAAM,SAAS,QAAQ,KAAK,CAAC;;;;;;;;;;;;;;;;;;AAmBjC,IAAa,aAAgB,UAC3B,SAAS;;;;;;;;;;;;;;;;;AAkBX,IAAa,YAAe,UAC1B,CAAC,CAAC;;;;;;;;;;;;;;;;;AAkBJ,IAAa,WAAc,UACzB,CAAC;;;;;;;;;;;;;;;;;AAkBH,IAAa,SAAS,gBAAsB,KAAK,IAAI;;;;;;;;;;;;;;;;;AAkBrD,IAAa,cAAc,gBAA2B,KAAK,SAAS;;;;;;;;;;;;;;;;;AAkBpE,IAAa,WAAW,gBAA2B,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqC9D,IAAa,gBACX,UAEA,OAAO,UAAU,YAAY,CAAC,CAAC;;;;;;;;;;;;;;;;;AAkBjC,IAAa,UAAU,gBAA2B,KAAK,KAAK;;;;;;;;;;;;;;;;;AAkB5D,IAAa,WAAW,gBAAwB,KAAK,MAAM;;;;;;;;;;;;;;;;;;;AAoB3D,IAAa,WAAW,gBAAwB,KAAK,MAAM;;;;;;;;;;;;;;;;;AAkB3D,IAAa,YAAY,gBAAyB,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkB9D,IAAa,aAAa,gBACxB,KAAK,UACL,KAAK,aACP;;;;;;;;;;;;;;;;;AAkBA,IAAa,WAAW,gBAAwB,KAAK,MAAM;;;;;;;;;;;;;;;;;AAkB3D,IAAa,YAAY,gBAA6B,KAAK,OAAO;;;;;;;;;;;;;;;;;AAkBlE,IAAa,QAAQ,gBAAwB,KAAK,GAAG;;;;;;;;;;;;;;;;;AAoBrD,IAAa,aAAa,gBAAwB,KAAK,QAAQ;;;;;;;;;;;;;;;;;AAoB/D,IAAa,WAAW,gBAAwB,KAAK,MAAM"}

package/types.d.ts

@@ -199,6 +199,16 @@ type MaybeKeys<T, TMaybeKeys extends keyof T> = {
  * @returns A type with specified keys required and others optional
  */
 type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * Applies {@link Defined} to the value types of specified keys while keeping the rest unchanged.
+ *
+ * @template T - The original type
+ * @template K - The keys whose value types should exclude `undefined`
+ * @returns A type with specified keys excluding `undefined` from their values and others unchanged
+ */
+type DefinedKeys<T, K extends keyof T> = Omit<T, K> & {
+    [Key in K]: Defined<T[K]>;
+};
 /**
  * Extracts the inner type from a Promise type.
  *
@@ -495,5 +505,14 @@ type AnyBoolean = boolean & {};
  * and leave the rest of the string unchanged.
  */
 type UpperFirst<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+type RequiredPropertyIfNeeded<TPropertyName extends string, TPropertyValue> = TPropertyValue extends undefined ? {
+    [P in TPropertyName]?: TPropertyValue;
+} : TPropertyValue extends AnyObject ? IsPartial<TPropertyValue> extends true ? {
+    [P in TPropertyName]?: TPropertyValue;
+} : {
+    [P in TPropertyName]: TPropertyValue;
+} : {
+    [P in TPropertyName]: TPropertyValue;
+};
 
-export type { AllPropertiesOptional, AnyBoolean, AnyFunction, AnyNumber, AnyObject, AnyPrimitive, AnyString, BrowserNativeObject, Class, CopyObject, DeepPartial, Defined, Dict, EmptyObject, ExtractEnumKeys, ExtractEnumValues, ExtractObjects, FalsyValues, Fn, HasKey, HasSpecificKey, IfEquals, IndexKeys, IsAny, IsArray, IsEmptyArray, IsFunction, IsObject, IsObjectEmpty, IsPartial, IsUnknown, KeyOfByValue, LiteralUnion, Maybe, MaybeArray, MaybeFalsy, MaybeFn, MaybeKeys, MaybePromise, MaybeValues, NonReadonly, NonUndefined, NotMaybe, NotNullable, Nullable, OmitByValue, OverrideKey, Params, PartialIf, PartialKeys, PickByValue, Primitive, ReadonlyKeys, RecordEntries, RenameKey, RequiredKeys, UnionToIntersection, Unpromise, UpperFirst, ValueOf, WithRequired, WritableKeys };
+export type { AllPropertiesOptional, AnyBoolean, AnyFunction, AnyNumber, AnyObject, AnyPrimitive, AnyString, BrowserNativeObject, Class, CopyObject, DeepPartial, Defined, DefinedKeys, Dict, EmptyObject, ExtractEnumKeys, ExtractEnumValues, ExtractObjects, FalsyValues, Fn, HasKey, HasSpecificKey, IfEquals, IndexKeys, IsAny, IsArray, IsEmptyArray, IsFunction, IsObject, IsObjectEmpty, IsPartial, IsUnknown, KeyOfByValue, LiteralUnion, Maybe, MaybeArray, MaybeFalsy, MaybeFn, MaybeKeys, MaybePromise, MaybeValues, NonReadonly, NonUndefined, NotMaybe, NotNullable, Nullable, OmitByValue, OverrideKey, Params, PartialIf, PartialKeys, PickByValue, Primitive, ReadonlyKeys, RecordEntries, RenameKey, RequiredKeys, RequiredPropertyIfNeeded, UnionToIntersection, Unpromise, UpperFirst, ValueOf, WithRequired, WritableKeys };

package/types.global.d.ts

@@ -200,6 +200,16 @@ type MaybeKeys<T, TMaybeKeys extends keyof T> = {
  * @returns A type with specified keys required and others optional
  */
 type RequiredKeys<T, K extends keyof T> = Omit<T, K> & Required<Pick<T, K>>;
+/**
+ * Applies {@link Defined} to the value types of specified keys while keeping the rest unchanged.
+ *
+ * @template T - The original type
+ * @template K - The keys whose value types should exclude `undefined`
+ * @returns A type with specified keys excluding `undefined` from their values and others unchanged
+ */
+type DefinedKeys<T, K extends keyof T> = Omit<T, K> & {
+    [Key in K]: Defined<T[K]>;
+};
 /**
  * Extracts the inner type from a Promise type.
  *
@@ -496,4 +506,13 @@ type AnyBoolean = boolean & {};
  * and leave the rest of the string unchanged.
  */
 type UpperFirst<S extends string> = S extends `${infer F}${infer R}` ? `${Uppercase<F>}${R}` : S;
+type RequiredPropertyIfNeeded<TPropertyName extends string, TPropertyValue> = TPropertyValue extends undefined ? {
+    [P in TPropertyName]?: TPropertyValue;
+} : TPropertyValue extends AnyObject ? IsPartial<TPropertyValue> extends true ? {
+    [P in TPropertyName]?: TPropertyValue;
+} : {
+    [P in TPropertyName]: TPropertyValue;
+} : {
+    [P in TPropertyName]: TPropertyValue;
+};
 

package/vibrate.cjs

@@ -1,21 +1,5 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-//#region src/vibrate.ts
-/**
-* ---header-docs-section---
-* # yummies/vibrate
-*
-* ## Description
-*
-* Thin wrapper around **`navigator.vibrate`** for mobile-style haptics: single pulses or patterned
-* on/off sequences. It no-ops when the API is missing or disabled, so UI code stays simple. Do not
-* rely on vibration for critical feedback because iOS and many desktops omit the API entirely.
-*
-* ## Usage
-*
-* ```ts
-* import { vibrate } from "yummies/vibrate";
-* ```
-*/
+//#region src/vibrate/vibrate.ts
 /**
 * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}
 * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).

package/vibrate.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"vibrate.cjs","names":[],"sources":["../src/vibrate.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/vibrate\n *\n * ## Description\n *\n * Thin wrapper around **`navigator.vibrate`** for mobile-style haptics: single pulses or patterned\n * on/off sequences. It no-ops when the API is missing or disabled, so UI code stays simple. Do not\n * rely on vibration for critical feedback because iOS and many desktops omit the API entirely.\n *\n * ## Usage\n *\n * ```ts\n * import { vibrate } from \"yummies/vibrate\";\n * ```\n */\n\n/**\n * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}\n * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).\n *\n * - **Single number** — vibrate for that many milliseconds, then stop.\n * - **Array of numbers** — alternating vibration and pause lengths in ms: `[vibrate, pause, vibrate, ...]`.\n *   Per the spec, values are clamped; odd-length arrays imply a trailing vibrate segment.\n *\n * If the API is unavailable or the user has disabled vibration, this function **does nothing**\n * (no throw). Call sites should not rely on vibration for critical UX.\n *\n * @param pattern - Duration in ms, or a pattern array as described above.\n *\n * @example\n * Short confirmation buzz (200 ms):\n * ```ts\n * vibrate(200);\n * ```\n *\n * @example\n * Double-pulse pattern: 100 ms on, 50 ms off, 100 ms on:\n * ```ts\n * vibrate([100, 50, 100]);\n * ```\n */\nexport const vibrate = (pattern: number | number[]) => {\n  if ('vibrate' in navigator) {\n    navigator.vibrate(pattern);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,WAAW,YAA+B;AACrD,KAAI,aAAa,UACf,WAAU,QAAQ,QAAQ"}
+{"version":3,"file":"vibrate.cjs","names":[],"sources":["../src/vibrate/vibrate.ts"],"sourcesContent":["/**\n * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}\n * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).\n *\n * - **Single number** — vibrate for that many milliseconds, then stop.\n * - **Array of numbers** — alternating vibration and pause lengths in ms: `[vibrate, pause, vibrate, ...]`.\n *   Per the spec, values are clamped; odd-length arrays imply a trailing vibrate segment.\n *\n * If the API is unavailable or the user has disabled vibration, this function **does nothing**\n * (no throw). Call sites should not rely on vibration for critical UX.\n *\n * @param pattern - Duration in ms, or a pattern array as described above.\n *\n * @example\n * Short confirmation buzz (200 ms):\n * ```ts\n * vibrate(200);\n * ```\n *\n * @example\n * Double-pulse pattern: 100 ms on, 50 ms off, 100 ms on:\n * ```ts\n * vibrate([100, 50, 100]);\n * ```\n */\nexport const vibrate = (pattern: number | number[]) => {\n  if ('vibrate' in navigator) {\n    navigator.vibrate(pattern);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,WAAW,YAA+B;CACrD,IAAI,aAAa,WACf,UAAU,QAAQ,OAAO;AAE7B"}

package/vibrate.d.ts

@@ -1,19 +1,3 @@
-/**
- * ---header-docs-section---
- * # yummies/vibrate
- *
- * ## Description
- *
- * Thin wrapper around **`navigator.vibrate`** for mobile-style haptics: single pulses or patterned
- * on/off sequences. It no-ops when the API is missing or disabled, so UI code stays simple. Do not
- * rely on vibration for critical feedback because iOS and many desktops omit the API entirely.
- *
- * ## Usage
- *
- * ```ts
- * import { vibrate } from "yummies/vibrate";
- * ```
- */
 /**
  * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}
  * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).

package/vibrate.js

@@ -1,20 +1,4 @@
-//#region src/vibrate.ts
-/**
-* ---header-docs-section---
-* # yummies/vibrate
-*
-* ## Description
-*
-* Thin wrapper around **`navigator.vibrate`** for mobile-style haptics: single pulses or patterned
-* on/off sequences. It no-ops when the API is missing or disabled, so UI code stays simple. Do not
-* rely on vibration for critical feedback because iOS and many desktops omit the API entirely.
-*
-* ## Usage
-*
-* ```ts
-* import { vibrate } from "yummies/vibrate";
-* ```
-*/
+//#region src/vibrate/vibrate.ts
 /**
 * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}
 * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).

package/vibrate.js.map

@@ -1 +1 @@
-{"version":3,"file":"vibrate.js","names":[],"sources":["../src/vibrate.ts"],"sourcesContent":["/**\n * ---header-docs-section---\n * # yummies/vibrate\n *\n * ## Description\n *\n * Thin wrapper around **`navigator.vibrate`** for mobile-style haptics: single pulses or patterned\n * on/off sequences. It no-ops when the API is missing or disabled, so UI code stays simple. Do not\n * rely on vibration for critical feedback because iOS and many desktops omit the API entirely.\n *\n * ## Usage\n *\n * ```ts\n * import { vibrate } from \"yummies/vibrate\";\n * ```\n */\n\n/**\n * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}\n * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).\n *\n * - **Single number** — vibrate for that many milliseconds, then stop.\n * - **Array of numbers** — alternating vibration and pause lengths in ms: `[vibrate, pause, vibrate, ...]`.\n *   Per the spec, values are clamped; odd-length arrays imply a trailing vibrate segment.\n *\n * If the API is unavailable or the user has disabled vibration, this function **does nothing**\n * (no throw). Call sites should not rely on vibration for critical UX.\n *\n * @param pattern - Duration in ms, or a pattern array as described above.\n *\n * @example\n * Short confirmation buzz (200 ms):\n * ```ts\n * vibrate(200);\n * ```\n *\n * @example\n * Double-pulse pattern: 100 ms on, 50 ms off, 100 ms on:\n * ```ts\n * vibrate([100, 50, 100]);\n * ```\n */\nexport const vibrate = (pattern: number | number[]) => {\n  if ('vibrate' in navigator) {\n    navigator.vibrate(pattern);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,WAAW,YAA+B;AACrD,KAAI,aAAa,UACf,WAAU,QAAQ,QAAQ"}
+{"version":3,"file":"vibrate.js","names":[],"sources":["../src/vibrate/vibrate.ts"],"sourcesContent":["/**\n * Triggers haptic feedback via the {@link https://developer.mozilla.org/en-US/docs/Web/API/Vibration_API | Vibration API}\n * when `navigator.vibrate` exists (common on Android Chrome; often missing on iOS Safari / desktop).\n *\n * - **Single number** — vibrate for that many milliseconds, then stop.\n * - **Array of numbers** — alternating vibration and pause lengths in ms: `[vibrate, pause, vibrate, ...]`.\n *   Per the spec, values are clamped; odd-length arrays imply a trailing vibrate segment.\n *\n * If the API is unavailable or the user has disabled vibration, this function **does nothing**\n * (no throw). Call sites should not rely on vibration for critical UX.\n *\n * @param pattern - Duration in ms, or a pattern array as described above.\n *\n * @example\n * Short confirmation buzz (200 ms):\n * ```ts\n * vibrate(200);\n * ```\n *\n * @example\n * Double-pulse pattern: 100 ms on, 50 ms off, 100 ms on:\n * ```ts\n * vibrate([100, 50, 100]);\n * ```\n */\nexport const vibrate = (pattern: number | number[]) => {\n  if ('vibrate' in navigator) {\n    navigator.vibrate(pattern);\n  }\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,IAAa,WAAW,YAA+B;CACrD,IAAI,aAAa,WACf,UAAU,QAAQ,OAAO;AAE7B"}