ts-data-forge 14.6.1 → 14.6.2

package/dist/functional/ternary-result/impl/ternary-result-unwrap-warn-throw.mjs

@@ -1,20 +1,30 @@
-import '@sindresorhus/is';
-import { unknownToString } from '../../../others/unknown-to-string.mjs';
+import { unknownToString } from '../../../others/index.mjs';
 import { isWarn } from './ternary-result-is-warn.mjs';
 import { variantName } from './variant-name.mjs';
-
-const unwrapWarnThrow = (result, toStr = unknownToString) => {
-  if (isWarn(result)) {
-    return result.warning;
-  }
-  const variant = variantName(result.$$tag);
-  throw new Error(
-    `Expected Warn but got ${variant}: ${toStr(
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      result.value
-    )}`
-  );
+/**
+ * Returns the Warn value or throws if the result is not Warn.
+ *
+ * @example
+ *
+ * ```ts
+ * const warnValue = TernaryResult.warn('pending', 'check logs');
+ *
+ * assert.strictEqual(TernaryResult.unwrapWarnThrow(warnValue), 'check logs');
+ *
+ * assert.throws(
+ *   () => TernaryResult.unwrapWarnThrow(TernaryResult.err('err')),
+ *   /Expected Warn/u,
+ * );
+ * ```
+ */
+export const unwrapWarnThrow = (result, toStr = unknownToString) => {
+    if (isWarn(result)) {
+        // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+        return result.warning;
+    }
+    const variant = variantName(result.$$tag);
+    throw new Error(`Expected Warn but got ${variant}: ${toStr(
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    result.value)}`);
 };
-
-export { unwrapWarnThrow };
-//# sourceMappingURL=ternary-result-unwrap-warn-throw.mjs.map
+//# sourceMappingURL=ternary-result-unwrap-warn-throw.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-unwrap-warn-throw.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-warn-throw.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn-throw.mts"],"sourcesContent":["import { unknownToString } from '../../../others/index.mjs';\nimport { type UnknownTernaryResult } from '../ternary-result.mjs';\nimport { isWarn } from './ternary-result-is-warn.mjs';\nimport { type UnwrapErr, type UnwrapOk, type UnwrapWarn } from './types.mjs';\nimport { variantName } from './variant-name.mjs';\n\n/**\n * Returns the Warn value or throws if the result is not Warn.\n *\n * @example\n *\n * ```ts\n * const warnValue = TernaryResult.warn('pending', 'check logs');\n *\n * assert.strictEqual(TernaryResult.unwrapWarnThrow(warnValue), 'check logs');\n *\n * assert.throws(\n *   () => TernaryResult.unwrapWarnThrow(TernaryResult.err('err')),\n *   /Expected Warn/u,\n * );\n * ```\n */\nexport const unwrapWarnThrow = <R extends UnknownTernaryResult>(\n  result: R,\n  toStr: (value: UnwrapOk<R> | UnwrapErr<R>) => string = unknownToString,\n): UnwrapWarn<R> => {\n  if (isWarn(result)) {\n    // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n    return result.warning as UnwrapWarn<R>;\n  }\n\n  const variant = variantName(result.$$tag);\n\n  throw new Error(\n    `Expected Warn but got ${variant}: ${toStr(\n      // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n      result.value as UnwrapOk<R> | UnwrapErr<R>,\n    )}`,\n  );\n};\n"],"names":[],"mappings":";;;;;AAsBO,MAAM,eAAA,GAAkB,CAC7B,MAAA,EACA,KAAA,GAAuD,eAAA,KACrC;AAClB,EAAA,IAAI,MAAA,CAAO,MAAM,CAAA,EAAG;AAElB,IAAA,OAAO,MAAA,CAAO,OAAA;AAAA,EAChB;AAEA,EAAA,MAAM,OAAA,GAAU,WAAA,CAAY,MAAA,CAAO,KAAK,CAAA;AAExC,EAAA,MAAM,IAAI,KAAA;AAAA,IACR,CAAA,sBAAA,EAAyB,OAAO,CAAA,EAAA,EAAK,KAAA;AAAA;AAAA,MAEnC,MAAA,CAAO;AAAA,KACR,CAAA;AAAA,GACH;AACF;;;;"}
+{"version":3,"file":"ternary-result-unwrap-warn-throw.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn-throw.mts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAE5D,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAEtD,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEjD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAC7B,MAAS,EACT,KAAK,GAAkD,eAAe,EACvD,EAAE;IACjB,IAAI,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;QACnB,oEAAoE;QACpE,OAAO,MAAM,CAAC,OAAwB,CAAC;IACzC,CAAC;IAED,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAE1C,MAAM,IAAI,KAAK,CACb,yBAAyB,OAAO,KAAK,KAAK;IACxC,oEAAoE;IACpE,MAAM,CAAC,KAAmC,CAC3C,EAAE,CACJ,CAAC;AACJ,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-unwrap-warn.mjs

@@ -1,9 +1,21 @@
 import { isWarn } from './ternary-result-is-warn.mjs';
-
-const unwrapWarn = (result) => (
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  isWarn(result) ? result.warning : void 0
-);
-
-export { unwrapWarn };
-//# sourceMappingURL=ternary-result-unwrap-warn.mjs.map
+/**
+ * Safely unwraps the Warn value.
+ *
+ * @example
+ *
+ * ```ts
+ * const warnValue = TernaryResult.warn('ok', 'careful');
+ *
+ * const okValue = TernaryResult.ok('ok');
+ *
+ * assert.strictEqual(TernaryResult.unwrapWarn(warnValue), 'careful');
+ *
+ * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
+ * assert.strictEqual(TernaryResult.unwrapWarn(okValue), undefined);
+ * ```
+ */
+export const unwrapWarn = (result) => 
+// eslint-disable-next-line total-functions/no-unsafe-type-assertion
+isWarn(result) ? result.warning : undefined;
+//# sourceMappingURL=ternary-result-unwrap-warn.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-unwrap-warn.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-unwrap-warn.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn.mts"],"sourcesContent":["import { type UnknownTernaryResult } from '../ternary-result.mjs';\nimport { isWarn } from './ternary-result-is-warn.mjs';\nimport { type UnwrapWarn } from './types.mjs';\n\n/**\n * Safely unwraps the Warn value.\n *\n * @example\n *\n * ```ts\n * const warnValue = TernaryResult.warn('ok', 'careful');\n *\n * const okValue = TernaryResult.ok('ok');\n *\n * assert.strictEqual(TernaryResult.unwrapWarn(warnValue), 'careful');\n *\n * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression\n * assert.strictEqual(TernaryResult.unwrapWarn(okValue), undefined);\n * ```\n */\nexport const unwrapWarn = <R extends UnknownTernaryResult>(\n  result: R,\n): UnwrapWarn<R> | undefined =>\n  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n  isWarn(result) ? (result.warning as UnwrapWarn<R>) : undefined;\n"],"names":[],"mappings":";;AAoBO,MAAM,aAAa,CACxB,MAAA;AAAA;AAAA,EAGA,MAAA,CAAO,MAAM,CAAA,GAAK,MAAA,CAAO,OAAA,GAA4B;AAAA;;;;"}
+{"version":3,"file":"ternary-result-unwrap-warn.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-unwrap-warn.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AAGtD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG,CACxB,MAAS,EACkB,EAAE;AAC7B,oEAAoE;AACpE,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,CAAE,MAAM,CAAC,OAAyB,CAAC,CAAC,CAAC,SAAS,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-warn.mjs

@@ -1,10 +1,23 @@
 import { WarnTypeTagName } from './tag.mjs';
-
-const warn = (value, warning) => ({
-  $$tag: WarnTypeTagName,
-  value,
-  warning
+/**
+ * Creates a `TernaryResult.Warn` containing the provided success value and
+ * warning.
+ *
+ * @example
+ *
+ * ```ts
+ * const caution = TernaryResult.warn({ id: 1 }, 'Needs review');
+ *
+ * assert.deepStrictEqual(caution, {
+ *   $$tag: 'ts-data-forge::Result.warn',
+ *   value: { id: 1 },
+ *   warning: 'Needs review',
+ * });
+ * ```
+ */
+export const warn = (value, warning) => ({
+    $$tag: WarnTypeTagName,
+    value,
+    warning,
 });
-
-export { warn };
-//# sourceMappingURL=ternary-result-warn.mjs.map
+//# sourceMappingURL=ternary-result-warn.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-warn.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-warn.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-warn.mts"],"sourcesContent":["import { type TernaryWarn } from '../ternary-result.mjs';\nimport { WarnTypeTagName } from './tag.mjs';\n\n/**\n * Creates a `TernaryResult.Warn` containing the provided success value and\n * warning.\n *\n * @example\n *\n * ```ts\n * const caution = TernaryResult.warn({ id: 1 }, 'Needs review');\n *\n * assert.deepStrictEqual(caution, {\n *   $$tag: 'ts-data-forge::Result.warn',\n *   value: { id: 1 },\n *   warning: 'Needs review',\n * });\n * ```\n */\nexport const warn = <const S, const W>(\n  value: S,\n  warning: W,\n): TernaryWarn<S, W> =>\n  ({\n    $$tag: WarnTypeTagName,\n    value,\n    warning,\n  }) as const;\n"],"names":[],"mappings":";;AAmBO,MAAM,IAAA,GAAO,CAClB,KAAA,EACA,OAAA,MAEC;AAAA,EACC,KAAA,EAAO,eAAA;AAAA,EACP,KAAA;AAAA,EACA;AACF,CAAA;;;;"}
+{"version":3,"file":"ternary-result-warn.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-warn.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE5C;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,CAClB,KAAQ,EACR,OAAU,EACS,EAAE,CACrB,CAAC;IACC,KAAK,EAAE,eAAe;IACtB,KAAK;IACL,OAAO;CACR,CAAU,CAAC"}

package/dist/functional/ternary-result/impl/ternary-result-zip.mjs

@@ -2,23 +2,51 @@ import { isErr } from './ternary-result-is-err.mjs';
 import { isWarn } from './ternary-result-is-warn.mjs';
 import { ok } from './ternary-result-ok.mjs';
 import { warn } from './ternary-result-warn.mjs';
-
-const zip = (resultA, resultB) => {
-  if (isErr(resultA)) {
-    return resultA;
-  }
-  if (isErr(resultB)) {
-    return resultB;
-  }
-  const pair = [resultA.value, resultB.value];
-  if (isWarn(resultA)) {
-    return warn(pair, resultA.warning);
-  }
-  if (isWarn(resultB)) {
-    return warn(pair, resultB.warning);
-  }
-  return ok(pair);
+/**
+ * Combines two `TernaryResult`s, prioritising Err over Warn over Ok.
+ *
+ * @example
+ *
+ * ```ts
+ * const okPair = TernaryResult.zip(
+ *   TernaryResult.ok('left'),
+ *   TernaryResult.ok(1),
+ * );
+ *
+ * const warnPair = TernaryResult.zip(
+ *   TernaryResult.warn('left', 'warn'),
+ *   TernaryResult.ok(1),
+ * );
+ *
+ * const errPair = TernaryResult.zip(
+ *   TernaryResult.ok('left'),
+ *   TernaryResult.err('err'),
+ * );
+ *
+ * assert.deepStrictEqual(okPair, TernaryResult.ok(['left', 1] as const));
+ *
+ * assert.deepStrictEqual(
+ *   warnPair,
+ *   TernaryResult.warn(['left', 1] as const, 'warn'),
+ * );
+ *
+ * assert.deepStrictEqual(errPair, TernaryResult.err('err'));
+ * ```
+ */
+export const zip = (resultA, resultB) => {
+    if (isErr(resultA)) {
+        return resultA;
+    }
+    if (isErr(resultB)) {
+        return resultB;
+    }
+    const pair = [resultA.value, resultB.value];
+    if (isWarn(resultA)) {
+        return warn(pair, resultA.warning);
+    }
+    if (isWarn(resultB)) {
+        return warn(pair, resultB.warning);
+    }
+    return ok(pair);
 };
-
-export { zip };
-//# sourceMappingURL=ternary-result-zip.mjs.map
+//# sourceMappingURL=ternary-result-zip.mjs.map

package/dist/functional/ternary-result/impl/ternary-result-zip.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result-zip.mjs","sources":["../../../../src/functional/ternary-result/impl/ternary-result-zip.mts"],"sourcesContent":["import { type TernaryResult } from '../ternary-result.mjs';\nimport { isErr } from './ternary-result-is-err.mjs';\nimport { isWarn } from './ternary-result-is-warn.mjs';\nimport { ok } from './ternary-result-ok.mjs';\nimport { warn } from './ternary-result-warn.mjs';\n\n/**\n * Combines two `TernaryResult`s, prioritising Err over Warn over Ok.\n *\n * @example\n *\n * ```ts\n * const okPair = TernaryResult.zip(\n *   TernaryResult.ok('left'),\n *   TernaryResult.ok(1),\n * );\n *\n * const warnPair = TernaryResult.zip(\n *   TernaryResult.warn('left', 'warn'),\n *   TernaryResult.ok(1),\n * );\n *\n * const errPair = TernaryResult.zip(\n *   TernaryResult.ok('left'),\n *   TernaryResult.err('err'),\n * );\n *\n * assert.deepStrictEqual(okPair, TernaryResult.ok(['left', 1] as const));\n *\n * assert.deepStrictEqual(\n *   warnPair,\n *   TernaryResult.warn(['left', 1] as const, 'warn'),\n * );\n *\n * assert.deepStrictEqual(errPair, TernaryResult.err('err'));\n * ```\n */\nexport const zip = <S1, W1, E1, S2, W2, E2>(\n  resultA: TernaryResult<S1, E1, W1>,\n  resultB: TernaryResult<S2, E2, W2>,\n): TernaryResult<readonly [S1, S2], E1 | E2, W1 | W2> => {\n  if (isErr(resultA)) {\n    return resultA;\n  }\n\n  if (isErr(resultB)) {\n    return resultB;\n  }\n\n  const pair = [resultA.value, resultB.value] as const;\n\n  if (isWarn(resultA)) {\n    return warn(pair, resultA.warning);\n  }\n\n  if (isWarn(resultB)) {\n    return warn(pair, resultB.warning);\n  }\n\n  return ok(pair);\n};\n"],"names":[],"mappings":";;;;;AAqCO,MAAM,GAAA,GAAM,CACjB,OAAA,EACA,OAAA,KACuD;AACvD,EAAA,IAAI,KAAA,CAAM,OAAO,CAAA,EAAG;AAClB,IAAA,OAAO,OAAA;AAAA,EACT;AAEA,EAAA,IAAI,KAAA,CAAM,OAAO,CAAA,EAAG;AAClB,IAAA,OAAO,OAAA;AAAA,EACT;AAEA,EAAA,MAAM,IAAA,GAAO,CAAC,OAAA,CAAQ,KAAA,EAAO,QAAQ,KAAK,CAAA;AAE1C,EAAA,IAAI,MAAA,CAAO,OAAO,CAAA,EAAG;AACnB,IAAA,OAAO,IAAA,CAAK,IAAA,EAAM,OAAA,CAAQ,OAAO,CAAA;AAAA,EACnC;AAEA,EAAA,IAAI,MAAA,CAAO,OAAO,CAAA,EAAG;AACnB,IAAA,OAAO,IAAA,CAAK,IAAA,EAAM,OAAA,CAAQ,OAAO,CAAA;AAAA,EACnC;AAEA,EAAA,OAAO,GAAG,IAAI,CAAA;AAChB;;;;"}
+{"version":3,"file":"ternary-result-zip.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/ternary-result-zip.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AACpD,OAAO,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAC;AACtD,OAAO,EAAE,EAAE,EAAE,MAAM,yBAAyB,CAAC;AAC7C,OAAO,EAAE,IAAI,EAAE,MAAM,2BAA2B,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,GAAG,GAAG,CACjB,OAAkC,EAClC,OAAkC,EACkB,EAAE;IACtD,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,IAAI,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC;QACnB,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,IAAI,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAU,CAAC;IAErD,IAAI,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,IAAI,MAAM,CAAC,OAAO,CAAC,EAAE,CAAC;QACpB,OAAO,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;IACrC,CAAC;IAED,OAAO,EAAE,CAAC,IAAI,CAAC,CAAC;AAClB,CAAC,CAAC"}

package/dist/functional/ternary-result/impl/types.mjs

@@ -1,2 +1,2 @@
-
-//# sourceMappingURL=types.mjs.map
+export {};
+//# sourceMappingURL=types.mjs.map

package/dist/functional/ternary-result/impl/types.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"types.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}
+{"version":3,"file":"types.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/types.mts"],"names":[],"mappings":""}

package/dist/functional/ternary-result/impl/variant-name.mjs

@@ -1,15 +1,13 @@
-import { ErrTypeTagName, WarnTypeTagName, OkTypeTagName } from './tag.mjs';
-
-const variantName = (tag) => {
-  switch (tag) {
-    case OkTypeTagName:
-      return "Ok";
-    case WarnTypeTagName:
-      return "Warn";
-    case ErrTypeTagName:
-      return "Err";
-  }
+import { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';
+/** @internal Returns the human readable variant label for the given tag. */
+export const variantName = (tag) => {
+    switch (tag) {
+        case OkTypeTagName:
+            return 'Ok';
+        case WarnTypeTagName:
+            return 'Warn';
+        case ErrTypeTagName:
+            return 'Err';
+    }
 };
-
-export { variantName };
-//# sourceMappingURL=variant-name.mjs.map
+//# sourceMappingURL=variant-name.mjs.map

package/dist/functional/ternary-result/impl/variant-name.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"variant-name.mjs","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"sourcesContent":["import { type UnknownTernaryResult } from '../ternary-result.mjs';\nimport { ErrTypeTagName, OkTypeTagName, WarnTypeTagName } from './tag.mjs';\n\n/** @internal Returns the human readable variant label for the given tag. */\nexport const variantName = (\n  tag: UnknownTernaryResult['$$tag'],\n): 'Ok' | 'Warn' | 'Err' => {\n  switch (tag) {\n    case OkTypeTagName:\n      return 'Ok';\n\n    case WarnTypeTagName:\n      return 'Warn';\n\n    case ErrTypeTagName:\n      return 'Err';\n  }\n};\n"],"names":[],"mappings":";;AAIO,MAAM,WAAA,GAAc,CACzB,GAAA,KAC0B;AAC1B,EAAA,QAAQ,GAAA;AAAK,IACX,KAAK,aAAA;AACH,MAAA,OAAO,IAAA;AAAA,IAET,KAAK,eAAA;AACH,MAAA,OAAO,MAAA;AAAA,IAET,KAAK,cAAA;AACH,MAAA,OAAO,KAAA;AAAA;AAEb;;;;"}
+{"version":3,"file":"variant-name.mjs","sourceRoot":"","sources":["../../../../src/functional/ternary-result/impl/variant-name.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,WAAW,CAAC;AAE3E,4EAA4E;AAC5E,MAAM,CAAC,MAAM,WAAW,GAAG,CACzB,GAAkC,EACX,EAAE;IACzB,QAAQ,GAAG,EAAE,CAAC;QACZ,KAAK,aAAa;YAChB,OAAO,IAAI,CAAC;QAEd,KAAK,eAAe;YAClB,OAAO,MAAM,CAAC;QAEhB,KAAK,cAAc;YACjB,OAAO,KAAK,CAAC;IACjB,CAAC;AACH,CAAC,CAAC"}

package/dist/functional/ternary-result/index.mjs

@@ -1,3 +1,2 @@
-import * as index from './impl/index.mjs';
-export { index as TernaryResult };
-//# sourceMappingURL=index.mjs.map
+export * from './ternary-result.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/functional/ternary-result/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../../src/functional/ternary-result/index.mts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC"}

package/dist/functional/ternary-result/ternary-result.mjs

@@ -1,3 +1,2 @@
-import * as index from './impl/index.mjs';
-export { index as TernaryResult };
-//# sourceMappingURL=ternary-result.mjs.map
+export * as TernaryResult from './impl/index.mjs';
+//# sourceMappingURL=ternary-result.mjs.map

package/dist/functional/ternary-result/ternary-result.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ternary-result.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";"}
+{"version":3,"file":"ternary-result.mjs","sourceRoot":"","sources":["../../../src/functional/ternary-result/ternary-result.mts"],"names":[],"mappings":"AAiDA,OAAO,KAAK,aAAa,MAAM,kBAAkB,CAAC"}

package/dist/guard/has-key.mjs

@@ -1,4 +1,43 @@
-const hasKey = (obj, key) => Object.hasOwn(obj, key);
-
-export { hasKey };
-//# sourceMappingURL=has-key.mjs.map
+/**
+ * Type guard function that checks if an object has a specific key as its own
+ * property.
+ *
+ * This function uses `Object.hasOwn()` to check if the given object has the
+ * specified key as its own property (not inherited). It acts as a type guard
+ * that narrows the type of the object to guarantee the key exists, enabling
+ * type-safe property access.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - When the guard returns `true`, TypeScript narrows the object type to include
+ *   the checked key
+ * - For union types, only union members that contain the key are preserved
+ * - The key's value type is preserved from the original object type when possible
+ *
+ * @example
+ *
+ * ```ts
+ * const maybeUser: Readonly<{ id?: number; name?: string }> = {
+ *   id: 42,
+ * } as const;
+ *
+ * if (hasKey(maybeUser, 'id')) {
+ *   // `maybeUser` is now known to have an `id` property.
+ *   assert.isTrue(maybeUser.id === 42);
+ * } else {
+ *   assert.fail();
+ * }
+ * ```
+ *
+ * @template R - The type of the input object, must extend UnknownRecord
+ * @template K - The type of the key to check for, must extend PropertyKey
+ *   (string | number | symbol)
+ * @param obj - The object to check for the presence of the key
+ * @param key - The key to check for in the object
+ * @returns `true` if the object has the specified key as its own property,
+ *   `false` otherwise. When `true`, TypeScript narrows the object type to
+ *   guarantee the key exists.
+ * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type
+ */
+export const hasKey = (obj, key) => Object.hasOwn(obj, key);
+//# sourceMappingURL=has-key.mjs.map

package/dist/guard/has-key.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"has-key.mjs","sources":["../../src/guard/has-key.mts"],"sourcesContent":["import { type ReadonlyRecord, type UnknownRecord } from 'ts-type-forge';\n\n/**\n * Type guard function that checks if an object has a specific key as its own\n * property.\n *\n * This function uses `Object.hasOwn()` to check if the given object has the\n * specified key as its own property (not inherited). It acts as a type guard\n * that narrows the type of the object to guarantee the key exists, enabling\n * type-safe property access.\n *\n * **Type Narrowing Behavior:**\n *\n * - When the guard returns `true`, TypeScript narrows the object type to include\n *   the checked key\n * - For union types, only union members that contain the key are preserved\n * - The key's value type is preserved from the original object type when possible\n *\n * @example\n *\n * ```ts\n * const maybeUser: Readonly<{ id?: number; name?: string }> = {\n *   id: 42,\n * } as const;\n *\n * if (hasKey(maybeUser, 'id')) {\n *   // `maybeUser` is now known to have an `id` property.\n *   assert.isTrue(maybeUser.id === 42);\n * } else {\n *   assert.fail();\n * }\n * ```\n *\n * @template R - The type of the input object, must extend UnknownRecord\n * @template K - The type of the key to check for, must extend PropertyKey\n *   (string | number | symbol)\n * @param obj - The object to check for the presence of the key\n * @param key - The key to check for in the object\n * @returns `true` if the object has the specified key as its own property,\n *   `false` otherwise. When `true`, TypeScript narrows the object type to\n *   guarantee the key exists.\n * @see {@link keyIsIn} - Similar function that narrows the key type instead of the object type\n */\nexport const hasKey = <\n  const R extends UnknownRecord,\n  const K extends PropertyKey,\n>(\n  obj: R,\n  key: K,\n): obj is HasKeyReturnType<R, K> => Object.hasOwn(obj, key);\n\n/**\n * @internal\n * When R is a union type (including the case with only one element), if any element in the union\n * contains K as a key, returns a type that narrows the union to only those elements that contain K as a key.\n * If none of the elements in the union contain K as a key, returns `ReadonlyRecord<K, unknown>`.\n * The result is made readonly.\n */\nexport type HasKeyReturnType<\n  R extends UnknownRecord,\n  K extends PropertyKey,\n> = R extends R // union distribution\n  ? K extends keyof R\n    ? string extends keyof R\n      ? ReadonlyRecord<K, R[keyof R]> & R\n      : number extends keyof R\n        ? ReadonlyRecord<K, R[keyof R]> & R\n        : symbol extends keyof R\n          ? ReadonlyRecord<K, R[keyof R]> & R\n          : R\n    : never // omit union member that does not have key K\n  : never; // dummy case for union distribution\n"],"names":[],"mappings":"AA2CO,MAAM,SAAS,CAIpB,GAAA,EACA,QACkC,MAAA,CAAO,MAAA,CAAO,KAAK,GAAG;;;;"}
+{"version":3,"file":"has-key.mjs","sourceRoot":"","sources":["../../src/guard/has-key.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,CAIpB,GAAM,EACN,GAAM,EACyB,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC"}

package/dist/guard/index.mjs

@@ -1,8 +1,8 @@
-export { hasKey } from './has-key.mjs';
-export { isNonEmptyString } from './is-non-empty-string.mjs';
-export { isNonNullObject } from './is-non-null-object.mjs';
-export { isPrimitive } from './is-primitive.mjs';
-export { isMutableRecord, isRecord } from './is-record.mjs';
-export { isBigint, isBoolean, isNonNullish, isNotBigint, isNotBoolean, isNotNull, isNotNumber, isNotString, isNotSymbol, isNotUndefined, isNull, isNullish, isNumber, isString, isSymbol, isUndefined } from './is-type.mjs';
-export { keyIsIn } from './key-is-in.mjs';
-//# sourceMappingURL=index.mjs.map
+export * from './has-key.mjs';
+export * from './is-non-empty-string.mjs';
+export * from './is-non-null-object.mjs';
+export * from './is-primitive.mjs';
+export * from './is-record.mjs';
+export * from './is-type.mjs';
+export * from './key-is-in.mjs';
+//# sourceMappingURL=index.mjs.map

package/dist/guard/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;"}
+{"version":3,"file":"index.mjs","sourceRoot":"","sources":["../../src/guard/index.mts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC"}

package/dist/guard/is-non-empty-string.mjs

@@ -1,4 +1,39 @@
-const isNonEmptyString = (s) => typeof s === "string" && s.length > 0;
-
-export { isNonEmptyString };
-//# sourceMappingURL=is-non-empty-string.mjs.map
+/**
+ * Type guard that checks if a value is a non-empty string.
+ *
+ * This function performs both a type check (ensuring the value is a string) and
+ * a length check (ensuring the string is not empty). It acts as a type guard
+ * that narrows the input type to exclude `null`, `undefined`, and empty
+ * strings.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Eliminates `null` and `undefined` from the type
+ * - Excludes empty string (`""`) from the type
+ * - Preserves literal string types when possible
+ * - Whitespace-only strings are considered non-empty
+ *
+ * @example
+ *
+ * ```ts
+ * const words: readonly (string | undefined)[] = [
+ *   'Ada',
+ *   undefined,
+ *   '',
+ *   'Lovelace',
+ * ] as const;
+ *
+ * const nonEmpty = words.filter(isNonEmptyString);
+ *
+ * assert.deepStrictEqual(nonEmpty, ['Ada', 'Lovelace']);
+ * ```
+ *
+ * @template S - The input type, which can include `string`, `null`, or
+ *   `undefined`
+ * @param s - The value to check
+ * @returns `true` if `s` is a string with length > 0, `false` otherwise. When
+ *   `true`, TypeScript narrows the type to exclude empty strings and nullish
+ *   values.
+ */
+export const isNonEmptyString = (s) => typeof s === 'string' && s.length > 0;
+//# sourceMappingURL=is-non-empty-string.mjs.map

package/dist/guard/is-non-empty-string.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-empty-string.mjs","sources":["../../src/guard/is-non-empty-string.mts"],"sourcesContent":["import { type NonEmptyString, type RelaxedExclude } from 'ts-type-forge';\n\n/**\n * Type guard that checks if a value is a non-empty string.\n *\n * This function performs both a type check (ensuring the value is a string) and\n * a length check (ensuring the string is not empty). It acts as a type guard\n * that narrows the input type to exclude `null`, `undefined`, and empty\n * strings.\n *\n * **Type Narrowing Behavior:**\n *\n * - Eliminates `null` and `undefined` from the type\n * - Excludes empty string (`\"\"`) from the type\n * - Preserves literal string types when possible\n * - Whitespace-only strings are considered non-empty\n *\n * @example\n *\n * ```ts\n * const words: readonly (string | undefined)[] = [\n *   'Ada',\n *   undefined,\n *   '',\n *   'Lovelace',\n * ] as const;\n *\n * const nonEmpty = words.filter(isNonEmptyString);\n *\n * assert.deepStrictEqual(nonEmpty, ['Ada', 'Lovelace']);\n * ```\n *\n * @template S - The input type, which can include `string`, `null`, or\n *   `undefined`\n * @param s - The value to check\n * @returns `true` if `s` is a string with length > 0, `false` otherwise. When\n *   `true`, TypeScript narrows the type to exclude empty strings and nullish\n *   values.\n */\nexport const isNonEmptyString = <S extends string | null | undefined>(\n  s: S,\n): s is NonEmptyString & RelaxedExclude<NonNullable<S>, ''> =>\n  typeof s === 'string' && s.length > 0;\n"],"names":[],"mappings":"AAuCO,MAAM,mBAAmB,CAC9B,CAAA,KAEA,OAAO,CAAA,KAAM,QAAA,IAAY,EAAE,MAAA,GAAS;;;;"}
+{"version":3,"file":"is-non-empty-string.mjs","sourceRoot":"","sources":["../../src/guard/is-non-empty-string.mts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAC9B,CAAI,EACsD,EAAE,CAC5D,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC"}

package/dist/guard/is-non-null-object.mjs

@@ -1,4 +1,36 @@
-const isNonNullObject = (u) => typeof u === "object" && u !== null;
-
-export { isNonNullObject };
-//# sourceMappingURL=is-non-null-object.mjs.map
+/**
+ * Type guard that checks if a value is a non-null object.
+ *
+ * This function checks if a value has type `"object"` according to the `typeof`
+ * operator and is not `null`. This includes all object types such as plain
+ * objects, arrays, dates, regular expressions, and other object instances, but
+ * excludes functions.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows `unknown` to `object`
+ * - Excludes `null`, `undefined`, and all primitive types
+ * - Excludes functions (they have `typeof` === `"function"`, not `"object"`)
+ * - Includes arrays, dates, regex, and other object instances
+ *
+ * **Note:** This function returns `true` for arrays. If you need
+ * record-oriented narrowing that excludes arrays, use `isRecord()` instead.
+ *
+ * @example
+ *
+ * ```ts
+ * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;
+ *
+ * const objects = mixed.filter(isNonNullObject);
+ *
+ * assert.deepStrictEqual(objects, [{ id: 1 }]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is an object and not `null`, `false` otherwise. When
+ *   `true`, TypeScript narrows the type to `object`.
+ * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)
+ */
+// eslint-disable-next-line @typescript-eslint/no-restricted-types
+export const isNonNullObject = (u) => typeof u === 'object' && u !== null;
+//# sourceMappingURL=is-non-null-object.mjs.map

package/dist/guard/is-non-null-object.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-non-null-object.mjs","sources":["../../src/guard/is-non-null-object.mts"],"sourcesContent":["/**\n * Type guard that checks if a value is a non-null object.\n *\n * This function checks if a value has type `\"object\"` according to the `typeof`\n * operator and is not `null`. This includes all object types such as plain\n * objects, arrays, dates, regular expressions, and other object instances, but\n * excludes functions.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows `unknown` to `object`\n * - Excludes `null`, `undefined`, and all primitive types\n * - Excludes functions (they have `typeof` === `\"function\"`, not `\"object\"`)\n * - Includes arrays, dates, regex, and other object instances\n *\n * **Note:** This function returns `true` for arrays. If you need\n * record-oriented narrowing that excludes arrays, use `isRecord()` instead.\n *\n * @example\n *\n * ```ts\n * const mixed: readonly unknown[] = [{ id: 1 }, null, 'Ada'] as const;\n *\n * const objects = mixed.filter(isNonNullObject);\n *\n * assert.deepStrictEqual(objects, [{ id: 1 }]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is an object and not `null`, `false` otherwise. When\n *   `true`, TypeScript narrows the type to `object`.\n * @see {@link isRecord} - For record-oriented type narrowing (excludes arrays)\n */\n// eslint-disable-next-line @typescript-eslint/no-restricted-types\nexport const isNonNullObject = (u: unknown): u is object =>\n  typeof u === 'object' && u !== null;\n"],"names":[],"mappings":"AAkCO,MAAM,kBAAkB,CAAC,CAAA,KAC9B,OAAO,CAAA,KAAM,YAAY,CAAA,KAAM;;;;"}
+{"version":3,"file":"is-non-null-object.mjs","sourceRoot":"","sources":["../../src/guard/is-non-null-object.mts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,kEAAkE;AAClE,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAU,EAAe,EAAE,CACzD,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,KAAK,IAAI,CAAC"}

package/dist/guard/is-primitive.mjs

@@ -1,17 +1,48 @@
-const isPrimitive = (u) => {
-  switch (typeof u) {
-    case "string":
-    case "number":
-    case "boolean":
-    case "undefined":
-    case "symbol":
-    case "bigint":
-      return true;
-    case "function":
-    case "object":
-      return u === null;
-  }
+
+/**
+ * Type guard that checks if a value is a primitive type.
+ *
+ * This function identifies JavaScript primitive types, which are immutable data
+ * types that are not objects. The primitive types are: `string`, `number`,
+ * `boolean`, `undefined`, `symbol`, `bigint`, and `null`.
+ *
+ * **Important Note:** Although `null` has `typeof null === "object"` due to a
+ * historical JavaScript quirk, this function correctly identifies `null` as a
+ * primitive value.
+ *
+ * **Type Narrowing Behavior:**
+ *
+ * - Narrows the input type to `Primitive` (union of all primitive types)
+ * - Excludes object types, arrays, functions, and other non-primitive values
+ * - Includes `null` despite its misleading `typeof` result
+ *
+ * @example
+ *
+ * ```ts
+ * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;
+ *
+ * const primitives = values.filter(isPrimitive);
+ *
+ * assert.deepStrictEqual(primitives, [42, 'Ada', null]);
+ * ```
+ *
+ * @param u - The value to check
+ * @returns `true` if `u` is a primitive type, `false` otherwise. When `true`,
+ *   TypeScript narrows the type to `Primitive`.
+ */
+export const isPrimitive = (u) => {
+    switch (typeof u) {
+        case 'string':
+        case 'number':
+        case 'boolean':
+        case 'undefined':
+        case 'symbol':
+        case 'bigint':
+            return true;
+        case 'function':
+        case 'object':
+            return u === null;
+    }
 };
 
-export { isPrimitive };
-//# sourceMappingURL=is-primitive.mjs.map
+//# sourceMappingURL=is-primitive.mjs.map

package/dist/guard/is-primitive.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"is-primitive.mjs","sources":["../../src/guard/is-primitive.mts"],"sourcesContent":["import { type Primitive } from 'ts-type-forge';\nimport { expectType } from '../expect-type.mjs';\n\n/**\n * Type guard that checks if a value is a primitive type.\n *\n * This function identifies JavaScript primitive types, which are immutable data\n * types that are not objects. The primitive types are: `string`, `number`,\n * `boolean`, `undefined`, `symbol`, `bigint`, and `null`.\n *\n * **Important Note:** Although `null` has `typeof null === \"object\"` due to a\n * historical JavaScript quirk, this function correctly identifies `null` as a\n * primitive value.\n *\n * **Type Narrowing Behavior:**\n *\n * - Narrows the input type to `Primitive` (union of all primitive types)\n * - Excludes object types, arrays, functions, and other non-primitive values\n * - Includes `null` despite its misleading `typeof` result\n *\n * @example\n *\n * ```ts\n * const values: readonly unknown[] = [42, 'Ada', null, { id: 1 }] as const;\n *\n * const primitives = values.filter(isPrimitive);\n *\n * assert.deepStrictEqual(primitives, [42, 'Ada', null]);\n * ```\n *\n * @param u - The value to check\n * @returns `true` if `u` is a primitive type, `false` otherwise. When `true`,\n *   TypeScript narrows the type to `Primitive`.\n */\nexport const isPrimitive = (u: unknown): u is Primitive => {\n  switch (typeof u) {\n    case 'string':\n    case 'number':\n    case 'boolean':\n    case 'undefined':\n    case 'symbol':\n    case 'bigint':\n      return true;\n    case 'function':\n    case 'object':\n      return u === null;\n  }\n};\n\nexpectType<\n  bigint | boolean | number | string | symbol | undefined | null,\n  Primitive\n>('=');\n"],"names":[],"mappings":"AAkCO,MAAM,WAAA,GAAc,CAAC,CAAA,KAA+B;AACzD,EAAA,QAAQ,OAAO,CAAA;AAAG,IAChB,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,SAAA;AAAA,IACL,KAAK,WAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,IAAA;AAAA,IACT,KAAK,UAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,CAAA,KAAM,IAAA;AAAA;AAEnB;;;;"}
+{"version":3,"file":"is-primitive.mjs","sourceRoot":"","sources":["../../src/guard/is-primitive.mts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,CAAC,CAAU,EAAkB,EAAE;IACxD,QAAQ,OAAO,CAAC,EAAE,CAAC;QACjB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ,CAAC;QACd,KAAK,SAAS,CAAC;QACf,KAAK,WAAW,CAAC;QACjB,KAAK,QAAQ,CAAC;QACd,KAAK,QAAQ;YACX,OAAO,IAAI,CAAC;QACd,KAAK,UAAU,CAAC;QAChB,KAAK,QAAQ;YACX,OAAO,CAAC,KAAK,IAAI,CAAC;IACtB,CAAC;AACH,CAAC,CAAC;AAEF,UAAU,CAGR,GAAG,CAAC,CAAC"}