nalloc 0.0.1 → 0.0.2

package/src/types.ts

@@ -31,6 +31,9 @@ export type None = NoneValueType & { readonly [SOME_BRAND]: false };
 /** Constant representing None. Use this instead of null/undefined for clarity. */
 export const NONE = undefined as None;
 
+/** Shared frozen empty array to avoid allocations. */
+export const EMPTY: readonly unknown[] = Object.freeze([]);
+
 /** A value that may or may not be present. Some(T) is the value itself; None is null/undefined. */
 export type Option<T> = Some<ValueType<T>> | None;
 
@@ -91,15 +94,23 @@ export function optionOf<T>(value: T): Option<T> {
   return isNone(value as Option<T>) ? NONE : (value as Some<T>);
 }
 
+export function someUnchecked<T>(value: T): Some<ValueType<T>> {
+  return value as Some<ValueType<T>>;
+}
+
 /**
- * Creates a Some value. Does not validate - use safe.some() for validation.
- * @param value - The value to wrap (must be non-null)
+ * Creates a Some value with runtime validation.
+ * @param value - The value to wrap
  * @returns The value typed as Some
+ * @throws TypeError if value is null or undefined
  * @example
  * some(42) // Some(42)
  */
 export function some<T>(value: ValueType<T>): Some<ValueType<T>> {
-  return value as Some<ValueType<T>>;
+  if (value === null || value === undefined) {
+    throw new TypeError('some() requires a non-nullable value');
+  }
+  return someUnchecked(value);
 }
 
 /** Constant representing None. Alias for NONE. */
@@ -125,10 +136,6 @@ function ResultErrorCtor<E>(this: ResultErrorShape<E>, error: E): void {
 /** The error wrapper type used internally. */
 export type ResultError<E> = ResultErrorShape<E>;
 
-function hasErrBrand(value: unknown): value is ResultError<unknown> {
-  return (value as Record<symbol, unknown>)?.[ERR_BRAND] === true;
-}
-
 /** Represents a failed Result containing an error. */
 export type Err<E> = ResultError<E>;
 
@@ -158,8 +165,9 @@ export type InferErr<T> = T extends Err<infer TError> ? Err<TError> : never;
 export function isOk<T>(result: Ok<T>): true;
 export function isOk<E>(result: Err<E>): false;
 export function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
-export function isOk<T, E>(result: Result<T, E>): boolean {
-  return !hasErrBrand(result);
+export function isOk(result: unknown): boolean;
+export function isOk(result: unknown): boolean {
+  return !(result as Record<symbol, unknown>)?.[ERR_BRAND];
 }
 
 /**
@@ -171,21 +179,30 @@ export function isOk<T, E>(result: Result<T, E>): boolean {
  * isErr(42)          // false (Ok value)
  */
 export function isErr<E>(result: Err<E>): true;
-export function isErr(result: Ok<any>): false;
+export function isErr(result: Ok<unknown>): false;
 export function isErr<T, E>(result: Result<T, E>): result is Err<E>;
-export function isErr<T, E>(result: Result<T, E>): boolean {
-  return hasErrBrand(result);
+export function isErr(result: unknown): result is Err<unknown>;
+export function isErr(result: unknown): boolean {
+  return (result as Record<symbol, unknown>)?.[ERR_BRAND] === true;
+}
+
+export function okUnchecked<T>(value: T): Ok<T> {
+  return value as Ok<T>;
 }
 
 /**
- * Creates an Ok value. Does not validate - use safe.ok() for validation.
+ * Creates an Ok value with runtime validation.
  * @param value - The success value
  * @returns The value typed as Ok
+ * @throws TypeError if value is an Err
  * @example
  * ok(42) // Ok(42)
  */
 export function ok<T>(value: T): Ok<T> {
-  return value as Ok<T>;
+  if (isErr(value)) {
+    throw new TypeError('ok() cannot wrap an Err value');
+  }
+  return okUnchecked(value);
 }
 
 /**
@@ -199,3 +216,24 @@ export function ok<T>(value: T): Ok<T> {
 export function err<E>(error: E): Err<E> {
   return new (ResultErrorCtor as unknown as new (error: E) => Err<E>)(error);
 }
+
+/** A value that may or may not be a Promise. */
+export type MaybePromise<T> = T | Promise<T> | PromiseLike<T>;
+
+/**
+ * Checks if a value is a thenable (has a .then method).
+ * @param value - The value to check
+ * @returns true if value is a PromiseLike
+ */
+export function isThenable<T>(value: MaybePromise<T>): value is PromiseLike<T> {
+  return typeof (value as PromiseLike<T>)?.then === 'function';
+}
+
+/**
+ * Checks if a value is synchronous (not a thenable).
+ * @param value - The value to check
+ * @returns true if value is not a PromiseLike
+ */
+export function isSync<T>(value: MaybePromise<T>): value is T {
+  return typeof (value as PromiseLike<T>)?.then !== 'function';
+}

package/src/unsafe.ts

@@ -1,47 +1,2 @@
-import type { Some, Ok } from './types.js';
-export { none, err } from './types.js';
-export type {
-  Some,
-  None,
-  Ok,
-  Err,
-  Option as OptionType,
-  OptionValue,
-  IsOption,
-  InferSome,
-  Result as ResultType,
-  ResultValue,
-  ResultErrorType,
-  IsResult,
-  InferErr,
-} from './types.js';
-export * as Option from './option.js';
-export * as Result from './result.js';
-
-/**
- * Creates a Some value without runtime validation.
- * Use when you are certain the value is non-nullable.
- * For validated creation, use safe.some() instead.
- * @param value - The value to wrap (assumed non-nullable)
- * @returns The value typed as Some
- * @example
- * some(42)   // Some(42)
- * some(null) // Some(null) - no validation, may cause issues
- */
-export function some<T>(value: T): Some<T> {
-  return value as unknown as Some<T>;
-}
-
-/**
- * Creates an Ok value without runtime validation.
- * Use when you are certain the value is not an Err.
- * For validated creation, use safe.ok() instead.
- * @param value - The success value (assumed not an Err)
- * @returns The value typed as Ok
- * @example
- * ok(42)          // Ok(42)
- * ok(err('fail')) // Ok(Err) - no validation, may cause issues
- */
-export function ok<T>(value: T): Ok<T> {
-  return value as Ok<T>;
-}
+export * from './safe.js';
+export { someUnchecked as some, okUnchecked as ok } from './types.js';

package/build/devtools.cjs

@@ -1,79 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get formatOption () {
-        return formatOption;
-    },
-    get formatResult () {
-        return formatResult;
-    },
-    get inspectOption () {
-        return inspectOption;
-    },
-    get inspectResult () {
-        return inspectResult;
-    },
-    get logOption () {
-        return logOption;
-    },
-    get logResult () {
-        return logResult;
-    },
-    get toJSONOption () {
-        return toJSONOption;
-    },
-    get toJSONResult () {
-        return toJSONResult;
-    }
-});
-const _typescjs = require("./types.cjs");
-function formatOption(opt) {
-    return (0, _typescjs.isSome)(opt) ? `Some(${String(opt)})` : 'None';
-}
-function formatResult(result) {
-    if ((0, _typescjs.isOk)(result)) {
-        return `Ok(${String(result)})`;
-    }
-    const error = result.error;
-    return `Err(${error instanceof Error ? error.message : String(error)})`;
-}
-function inspectOption(opt) {
-    return (0, _typescjs.isSome)(opt) ? {
-        kind: 'some',
-        value: opt
-    } : {
-        kind: 'none'
-    };
-}
-function inspectResult(result) {
-    return (0, _typescjs.isOk)(result) ? {
-        status: 'ok',
-        value: result
-    } : {
-        status: 'err',
-        error: result.error
-    };
-}
-function logOption(opt, logger = console.log) {
-    logger(formatOption(opt));
-}
-function logResult(result, logger = console.log) {
-    const tagged = inspectResult(result);
-    if (tagged.status === 'ok') {
-        logger(`Ok`, tagged.value);
-        return;
-    }
-    logger(`Err`, tagged.error);
-}
-const toJSONOption = inspectOption;
-const toJSONResult = inspectResult;
-
-//# sourceMappingURL=devtools.cjs.map

package/build/devtools.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/devtools.ts"],"sourcesContent":["import { Option, Result, isSome, isOk } from './types.js';\n\n/** Logger function signature for custom logging. */\ntype Logger = (message: string, ...args: unknown[]) => void;\n\n/**\n * Formats an Option as a human-readable string.\n * @param opt - The Option to format\n * @returns \"Some(value)\" or \"None\"\n * @example\n * formatOption(42)        // \"Some(42)\"\n * formatOption(null)      // \"None\"\n * formatOption(undefined) // \"None\"\n */\nexport function formatOption<T>(opt: Option<T>): string {\n  return isSome(opt) ? `Some(${String(opt)})` : 'None';\n}\n\n/**\n * Formats a Result as a human-readable string.\n * For Err containing an Error, displays the error message.\n * @param result - The Result to format\n * @returns \"Ok(value)\" or \"Err(error)\"\n * @example\n * formatResult(42)                      // \"Ok(42)\"\n * formatResult(err('fail'))             // \"Err(fail)\"\n * formatResult(err(new Error('oops')))  // \"Err(oops)\"\n */\nexport function formatResult<T, E>(result: Result<T, E>): string {\n  if (isOk(result)) {\n    return `Ok(${String(result)})`;\n  }\n  const error = (result as { error: E }).error;\n  return `Err(${error instanceof Error ? error.message : String(error)})`;\n}\n\n/**\n * Inspects an Option, returning a tagged object for debugging or serialization.\n * @param opt - The Option to inspect\n * @returns `{ kind: 'some', value: T }` or `{ kind: 'none' }`\n * @example\n * inspectOption(42)   // { kind: 'some', value: 42 }\n * inspectOption(null) // { kind: 'none' }\n */\nexport function inspectOption<T>(opt: Option<T>) {\n  return isSome(opt) ? { kind: 'some' as const, value: opt } : { kind: 'none' as const };\n}\n\n/**\n * Inspects a Result, returning a tagged object for debugging or serialization.\n * @param result - The Result to inspect\n * @returns `{ status: 'ok', value: T }` or `{ status: 'err', error: E }`\n * @example\n * inspectResult(42)           // { status: 'ok', value: 42 }\n * inspectResult(err('fail'))  // { status: 'err', error: 'fail' }\n */\nexport function inspectResult<T, E>(result: Result<T, E>) {\n  return isOk(result) ? { status: 'ok' as const, value: result } : { status: 'err' as const, error: (result as { error: E }).error };\n}\n\n/**\n * Logs an Option using the provided logger (defaults to console.log).\n * @param opt - The Option to log\n * @param logger - The logging function to use\n * @example\n * logOption(42)              // logs \"Some(42)\"\n * logOption(null)            // logs \"None\"\n * logOption(42, console.warn) // logs \"Some(42)\" as warning\n */\nexport function logOption<T>(opt: Option<T>, logger: Logger = console.log): void {\n  logger(formatOption(opt));\n}\n\n/**\n * Logs a Result using the provided logger (defaults to console.log).\n * Logs \"Ok\" with the value or \"Err\" with the error.\n * @param result - The Result to log\n * @param logger - The logging function to use\n * @example\n * logResult(42)              // logs \"Ok\", 42\n * logResult(err('fail'))     // logs \"Err\", \"fail\"\n * logResult(42, console.warn) // logs \"Ok\", 42 as warning\n */\nexport function logResult<T, E>(result: Result<T, E>, logger: Logger = console.log): void {\n  const tagged = inspectResult(result);\n  if (tagged.status === 'ok') {\n    logger(`Ok`, tagged.value);\n    return;\n  }\n  logger(`Err`, tagged.error);\n}\n\n/** Alias for inspectOption. Returns a JSON-serializable representation. */\nexport const toJSONOption = inspectOption;\n\n/** Alias for inspectResult. Returns a JSON-serializable representation. */\nexport const toJSONResult = inspectResult;\n"],"names":["formatOption","formatResult","inspectOption","inspectResult","logOption","logResult","toJSONOption","toJSONResult","opt","isSome","String","result","isOk","error","Error","message","kind","value","status","logger","console","log","tagged"],"mappings":";;;;;;;;;;;QAcgBA;eAAAA;;QAcAC;eAAAA;;QAgBAC;eAAAA;;QAYAC;eAAAA;;QAaAC;eAAAA;;QAcAC;eAAAA;;QAUHC;eAAAA;;QAGAC;eAAAA;;;0BAhGgC;AActC,SAASP,aAAgBQ,GAAc;IAC5C,OAAOC,IAAAA,gBAAM,EAACD,OAAO,CAAC,KAAK,EAAEE,OAAOF,KAAK,CAAC,CAAC,GAAG;AAChD;AAYO,SAASP,aAAmBU,MAAoB;IACrD,IAAIC,IAAAA,cAAI,EAACD,SAAS;QAChB,OAAO,CAAC,GAAG,EAAED,OAAOC,QAAQ,CAAC,CAAC;IAChC;IACA,MAAME,QAAQ,AAACF,OAAwBE,KAAK;IAC5C,OAAO,CAAC,IAAI,EAAEA,iBAAiBC,QAAQD,MAAME,OAAO,GAAGL,OAAOG,OAAO,CAAC,CAAC;AACzE;AAUO,SAASX,cAAiBM,GAAc;IAC7C,OAAOC,IAAAA,gBAAM,EAACD,OAAO;QAAEQ,MAAM;QAAiBC,OAAOT;IAAI,IAAI;QAAEQ,MAAM;IAAgB;AACvF;AAUO,SAASb,cAAoBQ,MAAoB;IACtD,OAAOC,IAAAA,cAAI,EAACD,UAAU;QAAEO,QAAQ;QAAeD,OAAON;IAAO,IAAI;QAAEO,QAAQ;QAAgBL,OAAO,AAACF,OAAwBE,KAAK;IAAC;AACnI;AAWO,SAAST,UAAaI,GAAc,EAAEW,SAAiBC,QAAQC,GAAG;IACvEF,OAAOnB,aAAaQ;AACtB;AAYO,SAASH,UAAgBM,MAAoB,EAAEQ,SAAiBC,QAAQC,GAAG;IAChF,MAAMC,SAASnB,cAAcQ;IAC7B,IAAIW,OAAOJ,MAAM,KAAK,MAAM;QAC1BC,OAAO,CAAC,EAAE,CAAC,EAAEG,OAAOL,KAAK;QACzB;IACF;IACAE,OAAO,CAAC,GAAG,CAAC,EAAEG,OAAOT,KAAK;AAC5B;AAGO,MAAMP,eAAeJ;AAGrB,MAAMK,eAAeJ"}

package/build/devtools.d.ts

@@ -1,82 +0,0 @@
-import { Option, Result } from './types.js';
-/** Logger function signature for custom logging. */
-type Logger = (message: string, ...args: unknown[]) => void;
-/**
- * Formats an Option as a human-readable string.
- * @param opt - The Option to format
- * @returns "Some(value)" or "None"
- * @example
- * formatOption(42)        // "Some(42)"
- * formatOption(null)      // "None"
- * formatOption(undefined) // "None"
- */
-export declare function formatOption<T>(opt: Option<T>): string;
-/**
- * Formats a Result as a human-readable string.
- * For Err containing an Error, displays the error message.
- * @param result - The Result to format
- * @returns "Ok(value)" or "Err(error)"
- * @example
- * formatResult(42)                      // "Ok(42)"
- * formatResult(err('fail'))             // "Err(fail)"
- * formatResult(err(new Error('oops')))  // "Err(oops)"
- */
-export declare function formatResult<T, E>(result: Result<T, E>): string;
-/**
- * Inspects an Option, returning a tagged object for debugging or serialization.
- * @param opt - The Option to inspect
- * @returns `{ kind: 'some', value: T }` or `{ kind: 'none' }`
- * @example
- * inspectOption(42)   // { kind: 'some', value: 42 }
- * inspectOption(null) // { kind: 'none' }
- */
-export declare function inspectOption<T>(opt: Option<T>): {
-    kind: "some";
-    value: import("./types.js").Some<Exclude<T, import("./types.js").NoneValueType>>;
-} | {
-    kind: "none";
-    value?: undefined;
-};
-/**
- * Inspects a Result, returning a tagged object for debugging or serialization.
- * @param result - The Result to inspect
- * @returns `{ status: 'ok', value: T }` or `{ status: 'err', error: E }`
- * @example
- * inspectResult(42)           // { status: 'ok', value: 42 }
- * inspectResult(err('fail'))  // { status: 'err', error: 'fail' }
- */
-export declare function inspectResult<T, E>(result: Result<T, E>): {
-    status: "ok";
-    value: import("./types.js").Ok<T>;
-    error?: undefined;
-} | {
-    status: "err";
-    error: E;
-    value?: undefined;
-};
-/**
- * Logs an Option using the provided logger (defaults to console.log).
- * @param opt - The Option to log
- * @param logger - The logging function to use
- * @example
- * logOption(42)              // logs "Some(42)"
- * logOption(null)            // logs "None"
- * logOption(42, console.warn) // logs "Some(42)" as warning
- */
-export declare function logOption<T>(opt: Option<T>, logger?: Logger): void;
-/**
- * Logs a Result using the provided logger (defaults to console.log).
- * Logs "Ok" with the value or "Err" with the error.
- * @param result - The Result to log
- * @param logger - The logging function to use
- * @example
- * logResult(42)              // logs "Ok", 42
- * logResult(err('fail'))     // logs "Err", "fail"
- * logResult(42, console.warn) // logs "Ok", 42 as warning
- */
-export declare function logResult<T, E>(result: Result<T, E>, logger?: Logger): void;
-/** Alias for inspectOption. Returns a JSON-serializable representation. */
-export declare const toJSONOption: typeof inspectOption;
-/** Alias for inspectResult. Returns a JSON-serializable representation. */
-export declare const toJSONResult: typeof inspectResult;
-export {};

package/build/devtools.js

@@ -1,43 +0,0 @@
-import { isSome, isOk } from "./types.js";
-export function formatOption(opt) {
-    return isSome(opt) ? `Some(${String(opt)})` : 'None';
-}
-export function formatResult(result) {
-    if (isOk(result)) {
-        return `Ok(${String(result)})`;
-    }
-    const error = result.error;
-    return `Err(${error instanceof Error ? error.message : String(error)})`;
-}
-export function inspectOption(opt) {
-    return isSome(opt) ? {
-        kind: 'some',
-        value: opt
-    } : {
-        kind: 'none'
-    };
-}
-export function inspectResult(result) {
-    return isOk(result) ? {
-        status: 'ok',
-        value: result
-    } : {
-        status: 'err',
-        error: result.error
-    };
-}
-export function logOption(opt, logger = console.log) {
-    logger(formatOption(opt));
-}
-export function logResult(result, logger = console.log) {
-    const tagged = inspectResult(result);
-    if (tagged.status === 'ok') {
-        logger(`Ok`, tagged.value);
-        return;
-    }
-    logger(`Err`, tagged.error);
-}
-export const toJSONOption = inspectOption;
-export const toJSONResult = inspectResult;
-
-//# sourceMappingURL=devtools.js.map

package/build/devtools.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/devtools.ts"],"sourcesContent":["import { Option, Result, isSome, isOk } from './types.js';\n\n/** Logger function signature for custom logging. */\ntype Logger = (message: string, ...args: unknown[]) => void;\n\n/**\n * Formats an Option as a human-readable string.\n * @param opt - The Option to format\n * @returns \"Some(value)\" or \"None\"\n * @example\n * formatOption(42)        // \"Some(42)\"\n * formatOption(null)      // \"None\"\n * formatOption(undefined) // \"None\"\n */\nexport function formatOption<T>(opt: Option<T>): string {\n  return isSome(opt) ? `Some(${String(opt)})` : 'None';\n}\n\n/**\n * Formats a Result as a human-readable string.\n * For Err containing an Error, displays the error message.\n * @param result - The Result to format\n * @returns \"Ok(value)\" or \"Err(error)\"\n * @example\n * formatResult(42)                      // \"Ok(42)\"\n * formatResult(err('fail'))             // \"Err(fail)\"\n * formatResult(err(new Error('oops')))  // \"Err(oops)\"\n */\nexport function formatResult<T, E>(result: Result<T, E>): string {\n  if (isOk(result)) {\n    return `Ok(${String(result)})`;\n  }\n  const error = (result as { error: E }).error;\n  return `Err(${error instanceof Error ? error.message : String(error)})`;\n}\n\n/**\n * Inspects an Option, returning a tagged object for debugging or serialization.\n * @param opt - The Option to inspect\n * @returns `{ kind: 'some', value: T }` or `{ kind: 'none' }`\n * @example\n * inspectOption(42)   // { kind: 'some', value: 42 }\n * inspectOption(null) // { kind: 'none' }\n */\nexport function inspectOption<T>(opt: Option<T>) {\n  return isSome(opt) ? { kind: 'some' as const, value: opt } : { kind: 'none' as const };\n}\n\n/**\n * Inspects a Result, returning a tagged object for debugging or serialization.\n * @param result - The Result to inspect\n * @returns `{ status: 'ok', value: T }` or `{ status: 'err', error: E }`\n * @example\n * inspectResult(42)           // { status: 'ok', value: 42 }\n * inspectResult(err('fail'))  // { status: 'err', error: 'fail' }\n */\nexport function inspectResult<T, E>(result: Result<T, E>) {\n  return isOk(result) ? { status: 'ok' as const, value: result } : { status: 'err' as const, error: (result as { error: E }).error };\n}\n\n/**\n * Logs an Option using the provided logger (defaults to console.log).\n * @param opt - The Option to log\n * @param logger - The logging function to use\n * @example\n * logOption(42)              // logs \"Some(42)\"\n * logOption(null)            // logs \"None\"\n * logOption(42, console.warn) // logs \"Some(42)\" as warning\n */\nexport function logOption<T>(opt: Option<T>, logger: Logger = console.log): void {\n  logger(formatOption(opt));\n}\n\n/**\n * Logs a Result using the provided logger (defaults to console.log).\n * Logs \"Ok\" with the value or \"Err\" with the error.\n * @param result - The Result to log\n * @param logger - The logging function to use\n * @example\n * logResult(42)              // logs \"Ok\", 42\n * logResult(err('fail'))     // logs \"Err\", \"fail\"\n * logResult(42, console.warn) // logs \"Ok\", 42 as warning\n */\nexport function logResult<T, E>(result: Result<T, E>, logger: Logger = console.log): void {\n  const tagged = inspectResult(result);\n  if (tagged.status === 'ok') {\n    logger(`Ok`, tagged.value);\n    return;\n  }\n  logger(`Err`, tagged.error);\n}\n\n/** Alias for inspectOption. Returns a JSON-serializable representation. */\nexport const toJSONOption = inspectOption;\n\n/** Alias for inspectResult. Returns a JSON-serializable representation. */\nexport const toJSONResult = inspectResult;\n"],"names":["isSome","isOk","formatOption","opt","String","formatResult","result","error","Error","message","inspectOption","kind","value","inspectResult","status","logOption","logger","console","log","logResult","tagged","toJSONOption","toJSONResult"],"mappings":"AAAA,SAAyBA,MAAM,EAAEC,IAAI,QAAQ,aAAa;AAc1D,OAAO,SAASC,aAAgBC,GAAc;IAC5C,OAAOH,OAAOG,OAAO,CAAC,KAAK,EAAEC,OAAOD,KAAK,CAAC,CAAC,GAAG;AAChD;AAYA,OAAO,SAASE,aAAmBC,MAAoB;IACrD,IAAIL,KAAKK,SAAS;QAChB,OAAO,CAAC,GAAG,EAAEF,OAAOE,QAAQ,CAAC,CAAC;IAChC;IACA,MAAMC,QAAQ,AAACD,OAAwBC,KAAK;IAC5C,OAAO,CAAC,IAAI,EAAEA,iBAAiBC,QAAQD,MAAME,OAAO,GAAGL,OAAOG,OAAO,CAAC,CAAC;AACzE;AAUA,OAAO,SAASG,cAAiBP,GAAc;IAC7C,OAAOH,OAAOG,OAAO;QAAEQ,MAAM;QAAiBC,OAAOT;IAAI,IAAI;QAAEQ,MAAM;IAAgB;AACvF;AAUA,OAAO,SAASE,cAAoBP,MAAoB;IACtD,OAAOL,KAAKK,UAAU;QAAEQ,QAAQ;QAAeF,OAAON;IAAO,IAAI;QAAEQ,QAAQ;QAAgBP,OAAO,AAACD,OAAwBC,KAAK;IAAC;AACnI;AAWA,OAAO,SAASQ,UAAaZ,GAAc,EAAEa,SAAiBC,QAAQC,GAAG;IACvEF,OAAOd,aAAaC;AACtB;AAYA,OAAO,SAASgB,UAAgBb,MAAoB,EAAEU,SAAiBC,QAAQC,GAAG;IAChF,MAAME,SAASP,cAAcP;IAC7B,IAAIc,OAAON,MAAM,KAAK,MAAM;QAC1BE,OAAO,CAAC,EAAE,CAAC,EAAEI,OAAOR,KAAK;QACzB;IACF;IACAI,OAAO,CAAC,GAAG,CAAC,EAAEI,OAAOb,KAAK;AAC5B;AAGA,OAAO,MAAMc,eAAeX,cAAc;AAG1C,OAAO,MAAMY,eAAeT,cAAc"}

package/build/testing.cjs

@@ -1,111 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: Object.getOwnPropertyDescriptor(all, name).get
-    });
-}
-_export(exports, {
-    get expectErr () {
-        return expectErr;
-    },
-    get expectNone () {
-        return expectNone;
-    },
-    get expectOk () {
-        return expectOk;
-    },
-    get expectSome () {
-        return expectSome;
-    },
-    get extendExpect () {
-        return extendExpect;
-    },
-    get matchers () {
-        return matchers;
-    }
-});
-const _typescjs = require("./types.cjs");
-const _devtoolscjs = require("./devtools.cjs");
-function expectOk(result, message) {
-    if ((0, _typescjs.isOk)(result)) {
-        return result;
-    }
-    const fallback = message ?? `Expected Ok(...) but received ${(0, _devtoolscjs.formatResult)(result)}`;
-    throw new Error(fallback);
-}
-function expectErr(result, message) {
-    if ((0, _typescjs.isErr)(result)) {
-        return result.error;
-    }
-    const fallback = message ?? `Expected Err(...) but received ${(0, _devtoolscjs.formatResult)(result)}`;
-    throw new Error(fallback);
-}
-function expectSome(opt, message) {
-    if ((0, _typescjs.isSome)(opt)) {
-        return opt;
-    }
-    const fallback = message ?? `Expected Some(...) but received ${(0, _devtoolscjs.formatOption)(opt)}`;
-    throw new Error(fallback);
-}
-function expectNone(opt, message) {
-    if ((0, _typescjs.isNone)(opt)) {
-        return;
-    }
-    const fallback = message ?? `Expected None but received ${(0, _devtoolscjs.formatOption)(opt)}`;
-    throw new Error(fallback);
-}
-const resultMatchers = {
-    toBeOk (received) {
-        const pass = (0, _typescjs.isOk)(received);
-        return {
-            pass,
-            message: ()=>pass ? 'Result is Ok as expected.' : `Expected Ok(...) but received ${(0, _devtoolscjs.formatResult)(received)}`
-        };
-    },
-    toBeErr (received) {
-        const pass = (0, _typescjs.isErr)(received);
-        return {
-            pass,
-            message: ()=>pass ? 'Result is Err as expected.' : `Expected Err(...) but received ${(0, _devtoolscjs.formatResult)(received)}`
-        };
-    },
-    toContainErr (received, expected) {
-        const pass = (0, _typescjs.isErr)(received) && received.error === expected;
-        return {
-            pass,
-            message: ()=>{
-                if (pass) return `Err matched expected value ${String(expected)}.`;
-                return `Expected Err(${String(expected)}) but received ${(0, _devtoolscjs.formatResult)(received)}`;
-            }
-        };
-    }
-};
-const optionMatchers = {
-    toBeSome (received) {
-        const pass = (0, _typescjs.isSome)(received);
-        return {
-            pass,
-            message: ()=>pass ? 'Option is Some as expected.' : `Expected Some(...) but received ${(0, _devtoolscjs.formatOption)(received)}`
-        };
-    },
-    toBeNone (received) {
-        const pass = (0, _typescjs.isNone)(received);
-        return {
-            pass,
-            message: ()=>pass ? 'Option is None as expected.' : `Expected None but received ${(0, _devtoolscjs.formatOption)(received)}`
-        };
-    }
-};
-const matchers = {
-    ...resultMatchers,
-    ...optionMatchers
-};
-function extendExpect(expectLike) {
-    expectLike.extend(matchers);
-}
-
-//# sourceMappingURL=testing.cjs.map

package/build/testing.cjs.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/testing.ts"],"sourcesContent":["import { isOk, isErr, isSome, isNone, Result, Err, Option } from './types.js';\nimport { formatOption, formatResult } from './devtools.js';\n\n/** Result shape returned by custom matchers. */\ntype MatcherResult = { pass: boolean; message(): string };\n\n/**\n * Asserts that a Result is Ok and returns the value.\n * Throws if the Result is Err.\n * @param result - The Result to check\n * @param message - Optional custom error message\n * @returns The Ok value\n * @throws {Error} If the Result is Err\n * @example\n * expectOk(ok(42))        // returns 42\n * expectOk(err('fail'))   // throws Error\n */\nexport function expectOk<T, E>(result: Result<T, E>, message?: string): T {\n  if (isOk(result)) {\n    return result;\n  }\n\n  const fallback = message ?? `Expected Ok(...) but received ${formatResult(result)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that a Result is Err and returns the error.\n * Throws if the Result is Ok.\n * @param result - The Result to check\n * @param message - Optional custom error message\n * @returns The error value\n * @throws {Error} If the Result is Ok\n * @example\n * expectErr(err('fail'))  // returns 'fail'\n * expectErr(ok(42))       // throws Error\n */\nexport function expectErr<T, E>(result: Result<T, E>, message?: string): E {\n  if (isErr(result)) {\n    return (result as Err<E>).error;\n  }\n\n  const fallback = message ?? `Expected Err(...) but received ${formatResult(result)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that an Option is Some and returns the value.\n * Throws if the Option is None.\n * @param opt - The Option to check\n * @param message - Optional custom error message\n * @returns The Some value\n * @throws {Error} If the Option is None\n * @example\n * expectSome(42)   // returns 42\n * expectSome(null) // throws Error\n */\nexport function expectSome<T>(opt: Option<T>, message?: string): T {\n  if (isSome(opt)) {\n    return opt;\n  }\n  const fallback = message ?? `Expected Some(...) but received ${formatOption(opt)}`;\n  throw new Error(fallback);\n}\n\n/**\n * Asserts that an Option is None.\n * Throws if the Option is Some.\n * @param opt - The Option to check\n * @param message - Optional custom error message\n * @throws {Error} If the Option is Some\n * @example\n * expectNone(null) // succeeds\n * expectNone(42)   // throws Error\n */\nexport function expectNone<T>(opt: Option<T>, message?: string): void {\n  if (isNone(opt)) {\n    return;\n  }\n  const fallback = message ?? `Expected None but received ${formatOption(opt)}`;\n  throw new Error(fallback);\n}\n\nconst resultMatchers = {\n  toBeOk(this: unknown, received: Result<unknown, unknown>): MatcherResult {\n    const pass = isOk(received);\n    return {\n      pass,\n      message: () => (pass ? 'Result is Ok as expected.' : `Expected Ok(...) but received ${formatResult(received)}`),\n    };\n  },\n  toBeErr(this: unknown, received: Result<unknown, unknown>): MatcherResult {\n    const pass = isErr(received);\n    return {\n      pass,\n      message: () => (pass ? 'Result is Err as expected.' : `Expected Err(...) but received ${formatResult(received)}`),\n    };\n  },\n  toContainErr(this: unknown, received: Result<unknown, unknown>, expected: unknown): MatcherResult {\n    const pass = isErr(received) && (received as Err<unknown>).error === expected;\n    return {\n      pass,\n      message: () => {\n        if (pass) return `Err matched expected value ${String(expected)}.`;\n        return `Expected Err(${String(expected)}) but received ${formatResult(received)}`;\n      },\n    };\n  },\n};\n\nconst optionMatchers = {\n  toBeSome(this: unknown, received: Option<unknown>): MatcherResult {\n    const pass = isSome(received);\n    return {\n      pass,\n      message: () => (pass ? 'Option is Some as expected.' : `Expected Some(...) but received ${formatOption(received)}`),\n    };\n  },\n  toBeNone(this: unknown, received: Option<unknown>): MatcherResult {\n    const pass = isNone(received);\n    return {\n      pass,\n      message: () => (pass ? 'Option is None as expected.' : `Expected None but received ${formatOption(received)}`),\n    };\n  },\n};\n\n/**\n * Custom matchers for Jest/Vitest.\n * Includes toBeOk, toBeErr, toContainErr, toBeSome, toBeNone.\n * Use with expect.extend(matchers) or extendExpect(expect).\n */\nexport const matchers = {\n  ...resultMatchers,\n  ...optionMatchers,\n};\n\n/** Interface for test frameworks with an extend method (Jest, Vitest). */\nexport type ExpectLike = {\n  extend(matchers: Record<string, (...args: any[]) => MatcherResult>): void;\n};\n\n/**\n * Extends a test framework's expect with Option and Result matchers.\n * @param expectLike - The expect object to extend (Jest/Vitest)\n * @example\n * import { expect } from 'vitest';\n * import { extendExpect } from 'nalloc/testing';\n * extendExpect(expect);\n *\n * // Now you can use:\n * expect(result).toBeOk();\n * expect(result).toBeErr();\n * expect(option).toBeSome();\n * expect(option).toBeNone();\n */\nexport function extendExpect(expectLike: ExpectLike): void {\n  expectLike.extend(matchers);\n}\n"],"names":["expectErr","expectNone","expectOk","expectSome","extendExpect","matchers","result","message","isOk","fallback","formatResult","Error","isErr","error","opt","isSome","formatOption","isNone","resultMatchers","toBeOk","received","pass","toBeErr","toContainErr","expected","String","optionMatchers","toBeSome","toBeNone","expectLike","extend"],"mappings":";;;;;;;;;;;QAqCgBA;eAAAA;;QAsCAC;eAAAA;;QA1DAC;eAAAA;;QAwCAC;eAAAA;;QAmGAC;eAAAA;;QAxBHC;eAAAA;;;0BApIoD;6BACtB;AAgBpC,SAASH,SAAeI,MAAoB,EAAEC,OAAgB;IACnE,IAAIC,IAAAA,cAAI,EAACF,SAAS;QAChB,OAAOA;IACT;IAEA,MAAMG,WAAWF,WAAW,CAAC,8BAA8B,EAAEG,IAAAA,yBAAY,EAACJ,SAAS;IACnF,MAAM,IAAIK,MAAMF;AAClB;AAaO,SAAST,UAAgBM,MAAoB,EAAEC,OAAgB;IACpE,IAAIK,IAAAA,eAAK,EAACN,SAAS;QACjB,OAAO,AAACA,OAAkBO,KAAK;IACjC;IAEA,MAAMJ,WAAWF,WAAW,CAAC,+BAA+B,EAAEG,IAAAA,yBAAY,EAACJ,SAAS;IACpF,MAAM,IAAIK,MAAMF;AAClB;AAaO,SAASN,WAAcW,GAAc,EAAEP,OAAgB;IAC5D,IAAIQ,IAAAA,gBAAM,EAACD,MAAM;QACf,OAAOA;IACT;IACA,MAAML,WAAWF,WAAW,CAAC,gCAAgC,EAAES,IAAAA,yBAAY,EAACF,MAAM;IAClF,MAAM,IAAIH,MAAMF;AAClB;AAYO,SAASR,WAAca,GAAc,EAAEP,OAAgB;IAC5D,IAAIU,IAAAA,gBAAM,EAACH,MAAM;QACf;IACF;IACA,MAAML,WAAWF,WAAW,CAAC,2BAA2B,EAAES,IAAAA,yBAAY,EAACF,MAAM;IAC7E,MAAM,IAAIH,MAAMF;AAClB;AAEA,MAAMS,iBAAiB;IACrBC,QAAsBC,QAAkC;QACtD,MAAMC,OAAOb,IAAAA,cAAI,EAACY;QAClB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,8BAA8B,CAAC,8BAA8B,EAAEX,IAAAA,yBAAY,EAACU,WAAW;QAChH;IACF;IACAE,SAAuBF,QAAkC;QACvD,MAAMC,OAAOT,IAAAA,eAAK,EAACQ;QACnB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,+BAA+B,CAAC,+BAA+B,EAAEX,IAAAA,yBAAY,EAACU,WAAW;QAClH;IACF;IACAG,cAA4BH,QAAkC,EAAEI,QAAiB;QAC/E,MAAMH,OAAOT,IAAAA,eAAK,EAACQ,aAAa,AAACA,SAA0BP,KAAK,KAAKW;QACrE,OAAO;YACLH;YACAd,SAAS;gBACP,IAAIc,MAAM,OAAO,CAAC,2BAA2B,EAAEI,OAAOD,UAAU,CAAC,CAAC;gBAClE,OAAO,CAAC,aAAa,EAAEC,OAAOD,UAAU,eAAe,EAAEd,IAAAA,yBAAY,EAACU,WAAW;YACnF;QACF;IACF;AACF;AAEA,MAAMM,iBAAiB;IACrBC,UAAwBP,QAAyB;QAC/C,MAAMC,OAAON,IAAAA,gBAAM,EAACK;QACpB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,gCAAgC,CAAC,gCAAgC,EAAEL,IAAAA,yBAAY,EAACI,WAAW;QACpH;IACF;IACAQ,UAAwBR,QAAyB;QAC/C,MAAMC,OAAOJ,IAAAA,gBAAM,EAACG;QACpB,OAAO;YACLC;YACAd,SAAS,IAAOc,OAAO,gCAAgC,CAAC,2BAA2B,EAAEL,IAAAA,yBAAY,EAACI,WAAW;QAC/G;IACF;AACF;AAOO,MAAMf,WAAW;IACtB,GAAGa,cAAc;IACjB,GAAGQ,cAAc;AACnB;AAqBO,SAAStB,aAAayB,UAAsB;IACjDA,WAAWC,MAAM,CAACzB;AACpB"}

package/build/testing.d.ts

@@ -1,85 +0,0 @@
-import { Result, Option } from './types.js';
-/** Result shape returned by custom matchers. */
-type MatcherResult = {
-    pass: boolean;
-    message(): string;
-};
-/**
- * Asserts that a Result is Ok and returns the value.
- * Throws if the Result is Err.
- * @param result - The Result to check
- * @param message - Optional custom error message
- * @returns The Ok value
- * @throws {Error} If the Result is Err
- * @example
- * expectOk(ok(42))        // returns 42
- * expectOk(err('fail'))   // throws Error
- */
-export declare function expectOk<T, E>(result: Result<T, E>, message?: string): T;
-/**
- * Asserts that a Result is Err and returns the error.
- * Throws if the Result is Ok.
- * @param result - The Result to check
- * @param message - Optional custom error message
- * @returns The error value
- * @throws {Error} If the Result is Ok
- * @example
- * expectErr(err('fail'))  // returns 'fail'
- * expectErr(ok(42))       // throws Error
- */
-export declare function expectErr<T, E>(result: Result<T, E>, message?: string): E;
-/**
- * Asserts that an Option is Some and returns the value.
- * Throws if the Option is None.
- * @param opt - The Option to check
- * @param message - Optional custom error message
- * @returns The Some value
- * @throws {Error} If the Option is None
- * @example
- * expectSome(42)   // returns 42
- * expectSome(null) // throws Error
- */
-export declare function expectSome<T>(opt: Option<T>, message?: string): T;
-/**
- * Asserts that an Option is None.
- * Throws if the Option is Some.
- * @param opt - The Option to check
- * @param message - Optional custom error message
- * @throws {Error} If the Option is Some
- * @example
- * expectNone(null) // succeeds
- * expectNone(42)   // throws Error
- */
-export declare function expectNone<T>(opt: Option<T>, message?: string): void;
-/**
- * Custom matchers for Jest/Vitest.
- * Includes toBeOk, toBeErr, toContainErr, toBeSome, toBeNone.
- * Use with expect.extend(matchers) or extendExpect(expect).
- */
-export declare const matchers: {
-    toBeSome(this: unknown, received: Option<unknown>): MatcherResult;
-    toBeNone(this: unknown, received: Option<unknown>): MatcherResult;
-    toBeOk(this: unknown, received: Result<unknown, unknown>): MatcherResult;
-    toBeErr(this: unknown, received: Result<unknown, unknown>): MatcherResult;
-    toContainErr(this: unknown, received: Result<unknown, unknown>, expected: unknown): MatcherResult;
-};
-/** Interface for test frameworks with an extend method (Jest, Vitest). */
-export type ExpectLike = {
-    extend(matchers: Record<string, (...args: any[]) => MatcherResult>): void;
-};
-/**
- * Extends a test framework's expect with Option and Result matchers.
- * @param expectLike - The expect object to extend (Jest/Vitest)
- * @example
- * import { expect } from 'vitest';
- * import { extendExpect } from 'nalloc/testing';
- * extendExpect(expect);
- *
- * // Now you can use:
- * expect(result).toBeOk();
- * expect(result).toBeErr();
- * expect(option).toBeSome();
- * expect(option).toBeNone();
- */
-export declare function extendExpect(expectLike: ExpectLike): void;
-export {};