{"version":3,"file":"index.cjs","names":["IGNORABLES","err","message: string | undefined","err","Never","err","link","err","context","Never","err","inspect","props","stack: KindStackItem[] | undefined"],"sources":["../src/type-guards/isError.ts","../src/type-guards/isFetchError.ts","../src/type-guards/isFetchResponse.ts","../src/type-guards/isKindError.ts","../src/type-guards/isKindErrorType.ts","../src/type-guards/isStringifyable.ts","../src/utils/asKindSubtype.ts","../src/utils/asKindType.ts","../src/utils/error-proxies.ts","../src/utils/toStackTrace.ts","../src/utils/getStackTrace.ts","../src/utils/renameFunction.ts","../src/instance/toJSONFn.ts","../src/link.ts","../src/instance/toStringFn.ts","../src/createKindError.ts","../src/types/types.ts"],"sourcesContent":["import type { JsError } from \"~/types\";\n\nexport function isError(val: unknown): val is JsError {\n  return val instanceof Error;\n}\n","import type { FetchError } from \"~/types\";\nimport { isObject } from \"inferred-types/runtime\";\n\n/**\n * type guard which tests whether `val` is a failed `Response` object\n * from a `fetch` call.\n */\nexport function isFetchError(val: unknown): val is FetchError {\n  return isObject(val) && val instanceof Response && val.ok === false;\n}\n","import { isObject } from \"inferred-types\";\n\n/**\n * A type guard which tests whether `val` is a `Response` object from the\n * **fetch** API.\n *\n * **Related:** `isFetchError()`\n */\nexport function isFetchResponse(val: unknown): val is Response {\n  return isObject(val)\n    && \"ok\" in val\n    && typeof val.ok === \"boolean\"\n    && \"body\" in val\n    && \"statusText\" in val;\n}\n","import type { KebabCase } from \"inferred-types\";\nimport type { KindError } from \"~/types\";\nimport { isString, toKebabCase } from \"inferred-types\";\nimport { isError } from \"./isError\";\n\n/**\n * Type guard to detect whether `val` passed in is a `KindError`.\n *\n * - you may _optionally_ test for a specific `kind` of `KindError`\n * - when testing for a specific \"kind\" the _comparator_ and _kind_ are normalized\n *   to a kebab cased variant to increase matching likelihood\n *     - this is meant as convenience to the caller; if you want a stricter\n *       matching then use the `KindErrorType`'s `is(val)` type guard.\n */\nexport function isKindError<\n  K extends string | undefined,\n>(\n  val: unknown,\n  kind: K = undefined as K,\n): val is K extends string ? KindError<KebabCase<K>> : KindError {\n  return isError(val)\n    && \"__kind\" in val && val.__kind === \"KindError\"\n    && \"kind\" in val\n    && \"type\" in val\n    && \"stackTrace\" in val\n    && (\n      (isString(kind) && isString(val.kind) && toKebabCase(val.kind) === toKebabCase(kind))\n      || (!isString(kind))\n    );\n}\n","import type { KindErrorType } from \"~/types\";\n\nexport function isKindErrorType(val: unknown): val is KindErrorType {\n  return typeof val === \"function\" && \"__kind\" in val && val.__kind === \"KindErrorType\";\n}\n","import type { Stringifyable } from \"~/types\";\nimport { isArray, isNumber, isObject, isString } from \"inferred-types/runtime\";\n\nexport function isStringifyable(val: unknown): val is Stringifyable {\n  return isString(val) || isNumber(val) || isObject(val) || isArray(val);\n}\n","import type { AsKindSubType } from \"~/types\";\nimport { retainAfter } from \"inferred-types\";\n\nexport function asKindSubType<T extends string>(kind: T) {\n  return (\n    retainAfter(kind, \"/\") === \"\"\n      ? undefined\n      : String(retainAfter(kind, \"/\")).includes(\"|\")\n        ? String(retainAfter(kind, \"/\")).split(\"|\").map(i => i.trim()).join(\" | \")\n        : String(retainAfter(kind, \"/\"))\n  ) as AsKindSubType<T>;\n}\n","import type { AsKindType } from \"~/types\";\nimport { retainUntil } from \"inferred-types\";\n\n/**\n * extracts the `type` from the `kind` property found\n */\nexport function asKindType<T extends string>(kind: T) {\n  return retainUntil(kind, \"/\") as AsKindType<T>;\n}\n","import type { Dictionary, Narrowable } from \"inferred-types/types\";\nimport type { FetchError, JsError, KindError, KindErrorType, KindStackItem } from \"../types\";\nimport { parse } from \"error-stack-parser-es/lite\";\nimport { hasIndexOf, isObject, isString, isUndefined } from \"inferred-types/runtime\";\nimport { relative } from \"pathe\";\nimport { createKindError, isError } from \"~\";\n\nconst IGNORABLES = [\"@vitest/runner\", \"node:\", \"native\"];\n\n/**\n * creates a structured stack trace (e.g., `KindStackTrace[]`)\n * from a normal error.\n */\nexport function createStackTrace<T extends JsError>(\n  err: T,\n): KindStackItem[] {\n  return parse(err).slice(1).filter(\n    i => !IGNORABLES.some(has => i.file && i.file.includes(has)),\n  ).map(i => ({\n    ...i,\n    file: i.file ? relative(\".\", i.file) : undefined,\n  }));\n}\n\n/**\n * Creates a `KindError` from another error\n */\nexport function errorFromError<\n  TKind extends string,\n  TCtx extends Record<string, N>,\n  TErr extends JsError,\n  N extends Narrowable,\n>(\n  kind: TKind,\n  ctx: TCtx,\n  err: TErr,\n): KindError<TKind, string, TCtx> {\n  const context = {\n    ...ctx,\n    underlying: err,\n  };\n\n  const factory = createKindError(\n    kind,\n    context,\n  ) as unknown as KindErrorType<TKind, typeof context>;\n\n  const error = (factory as any)(err.message) as unknown as KindError<TKind, string, TCtx>;\n\n  (error as any).cause = err;\n  if (err.stack) {\n    error.stackTrace = () => createStackTrace(err);\n  }\n\n  return error as KindError<TKind, string, TCtx>;\n};\n\nexport function errorFromResponse<\n  TKind extends string,\n  TCtx extends Record<string, N>,\n  TErr extends FetchError,\n  N extends Narrowable,\n>(\n  kind: TKind,\n  ctx: TCtx,\n  res: TErr,\n) {\n  const context = {\n    ...ctx,\n    underlying: res,\n  };\n\n  const wrapper = createKindError(kind, context) as unknown as KindErrorType<TKind, typeof context>;\n\n  return (wrapper as any)((res as any).statusText);\n}\n\nexport function getMessageInObject<\n  T extends Dictionary,\n>(\n  obj: T,\n  ...props: readonly string[]\n) {\n  let message: string | undefined;\n\n  props.forEach((p) => {\n    if (p in obj && isUndefined(message)) {\n      if (isString(obj[p])) {\n        message = obj[p];\n      }\n      else if (isError(obj[p])) {\n        message = obj[p].message;\n      }\n    }\n  });\n\n  return message;\n}\n\nexport function errorFromObject<\n  TKind extends string,\n  TCtx extends Record<string, N>,\n  TObj extends Dictionary,\n  N extends Narrowable,\n>(\n  kind: TKind,\n  ctx: TCtx,\n  obj: TObj,\n) {\n  const message = getMessageInObject(\n    obj,\n    \"message\",\n    \"msg\",\n    \"error\",\n    \"cause\",\n    \"reason\",\n    \"err\",\n    \"code\",\n  ) || `Unknown Condition`;\n\n  const context = {\n    ...ctx,\n    underlying: obj,\n  };\n\n  const error = createKindError(kind, context) as unknown as KindErrorType<TKind, typeof context>;\n\n  return (error as any)(message);\n}\n\n/**\n * proxies from an error being represented in an unknown\n * structure (as `Error`, `Response`, etc. have already\n * been tried)\n */\nexport function errorFromRest<\n  TKind extends string,\n  TCtx extends Record<string, N>,\n  TRest,\n  N extends Narrowable,\n>(\n  kind: TKind,\n  ctx: TCtx,\n  rest: TRest,\n) {\n  const message = isString(rest)\n    ? rest\n    : isObject(rest)\n      ? hasIndexOf(rest, \"error\") && typeof (rest as any).error === \"string\"\n        ? (rest as any).error\n        : hasIndexOf(rest, \"msg\") && typeof (rest as any).msg === \"string\"\n          ? (rest as any).msg\n          : hasIndexOf(rest, \"message\") && typeof (rest as any).message === \"string\"\n            ? (rest as any).message\n            : \"Unknown\"\n      : \"Unknown\";\n\n  const error = createKindError(\n    kind,\n    {\n      ...ctx,\n      underlying: rest,\n    },\n  ) as unknown as KindErrorType<TKind, Record<string, unknown>>;\n\n  return (error as any)(message as string);\n}\n","import type { KindStackItem } from \"~/types\";\nimport { parse } from \"error-stack-parser-es/lite\";\nimport { relative } from \"pathe\";\n\nconst IGNORABLES = [\"@vitest/runner\", \"node:\", \"native\"];\n\n/**\n * converts a normal Javascript _stack_ string into a structured\n * stack trace.\n */\nexport function toStackTrace<T extends string>(stack: T): KindStackItem[] {\n  const err = new Error(\"Stack Parser\");\n  err.stack = stack;\n\n  try {\n    return parse(err)\n      .filter(i => !IGNORABLES.some(has => i.file && i.file.includes(has)))\n      .map(i => ({\n        ...i,\n        file: i.file ? relative(\".\", i.file) : undefined,\n      }));\n  }\n  catch (e) {\n    console.warn(`Failed to parse stack trace: ${e instanceof Error ? e.message : String(e)}`);\n    return [];\n  }\n}\n","import type { KindStackItem } from \"~/types\";\nimport { isString, Never } from \"inferred-types\";\nimport { toStackTrace } from \"./toStackTrace\";\n\nexport function getStackTrace(): KindStackItem[] {\n  const { stack } = new Error(\"Stack Trace\");\n\n  return isString(stack)\n    ? toStackTrace(stack)\n    : Never;\n}\n","import type { TypedFunction } from \"inferred-types/types\";\n\nexport function renameFunction<T extends TypedFunction, N extends string>(\n  fn: T,\n  name: N,\n) {\n  return Object.defineProperty(\n    (...args: any[]) => {\n      return fn(...args); // <-- fix here\n    },\n    \"name\",\n    { value: name, writable: false },\n  ) as T;\n}\n","import type { KindError } from \"~/types\";\n\nexport function toJsonFn<T extends KindError<any, any, any>>(\n  err: T,\n) {\n  return () => {\n    const stack = err.stackTrace();\n    const first = stack[0];\n    return first?.function\n      ? {\n          name: err.name,\n          kind: err.kind,\n          message: err.message,\n          context: err.context,\n          fn: first.function,\n          line: first.line,\n          stack: err.stack,\n        }\n      : {\n          name: err.name,\n          kind: err.kind,\n          message: err.message,\n          context: err.context,\n          line: first?.line,\n          stack: err.stack,\n        };\n  };\n}\n","import { resolve } from \"pathe\";\n\n/**\n * **link**`(text, link)`\n *\n * Prints a link to the terminal using a relatively new\n * [standard](https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda) for making pretty links.\n *\n * You can use the following protocols for your links:\n * - `http` / `https`\n * - `file` (note format is `file://hostname/path/to/file.txt` and hostname\n * IS required)\n * - `mailto`\n * - `\n */\nexport function link(text: string, link: string) {\n  return `\\x1B]8;;${link}\\x1B\\\\${text}\\x1B]8;;\\x1B\\\\`;\n}\n\nexport function fileLink(text?: string) {\n  if (text) {\n    return link(text, resolve(text));\n  }\n  return \"\";\n}\n\n// https://huggingface.co/bartowski/Llama-3.2-3B-Instruct-GGUF\n\n/**\n * returns the URL to a Hugging Face model repo.\n *\n * **Related:** `linkToModel()`, `link()`\n */\nexport function urlToModel(model: string) {\n  return `https://huggingface.co/${model}`;\n}\n","import type { Dictionary } from \"inferred-types/types\";\nimport type { KindError, Stringifyable } from \"~/types\";\nimport chalk from \"chalk\";\nimport { Never } from \"inferred-types/constants\";\nimport { resolve } from \"pathe\";\nimport { fileLink, link } from \"~/link\";\nimport { isStringifyable } from \"~/type-guards\";\n\n// TODO: refactor call signature\n\n/**\n * creates the `toString()` function for a `KindError`\n */\nexport function toStringFn<\n  TErr extends KindError<TName, TMsg, TCtx>,\n  TName extends string,\n  TMsg extends string,\n  const TCtx extends Record<string, unknown>,\n>(\n  err: TErr,\n): () => string {\n  const { name, message, stackTrace } = err;\n\n  return () => {\n    const frames = stackTrace();\n    const first = frames[0];\n    const func = first?.function\n      ? ` inside the function ${`${chalk.bold(first.function)}()`}`\n      : \"\";\n    const fileInfo = first?.file && first?.line\n      ? `\\n\\n${chalk.italic(\"in \")}file ${chalk.bold.blue(link(first.file, resolve(first.file)))} at line ${chalk.bold(first.line)}${func}`\n      : \"\";\n\n    const stack = frames.slice(1).length > 0\n      ? `\\n${frames.slice(1).map(l => `    - ${chalk.blue(fileLink(l?.file))}:${l?.line}:${l?.col}${l?.function ? ` in ${chalk.bold(`${l?.function}()`)}` : \"\"}`).join(\"\\n\")}`\n      : \"\";\n\n    const context = Object.keys(err.context).length > 0\n      ? `\\n\\nContext:\\n${Object.keys(err.context).map(\n        (key) => {\n          const context = err.context as Dictionary;\n          const value = (\n            key in context\n              ? isStringifyable(context[key])\n                ? context[key]\n                : Never\n              : null\n          ) as Stringifyable;\n\n          return `\\n  ${`${chalk.bold.green(key)}: `}${JSON.stringify(value)}`;\n        },\n      )}`\n      : \"\";\n\n    return `\\n${chalk.bold.red(`${name} Error: `)}${message}${fileInfo}${stack}${context}`;\n  };\n}\n","import type { Contains, EmptyObject, Err, MergeObjects } from \"inferred-types\";\nimport type { AsContextShape, KindError, KindErrorType, KindStackItem, ResolveContext } from \"~/types\";\nimport { inspect } from \"node:util\";\nimport {\n  createFnWithProps,\n  err,\n  isError,\n  isObject,\n  isString,\n  toPascalCase,\n} from \"inferred-types\";\nimport {\n  asKindSubType,\n  asKindType,\n  createStackTrace,\n  getMessageInObject,\n  getStackTrace,\n  renameFunction,\n} from \"~/utils\";\nimport { toJsonFn, toStringFn } from \"./instance\";\nimport { isKindError } from \"./type-guards\";\n\ntype Rtn<\n  TName extends string,\n  TContext extends Record<string, unknown>,\n> = Contains<TName, \"<\" | \">\" | \"[\" | \"]\" | \"(\" | \")\"> extends true\n  ? Err<\n    \"invalid-name\",\n    `The name for a KindError must not include any of the following characters: \"<\", \">\", \"[\", \"]\", \"(\", \")\"`\n  >\n  : KindErrorType<TName, TContext>;\n\n/**\n * **createKindError**`(name, context)`\n *\n * Creates a `KindErrorType` which can then be called to create\n * the underlying `KindError` instance.\n */\nexport function createKindError<\n  const TName extends string,\n  const TContext extends Record<string, unknown>,\n>(\n  name: TName,\n  context: TContext = {} as EmptyObject as TContext,\n): Rtn<TName, TContext> {\n  if (/[<>[\\]()]/.test(name)) {\n    return err(\"invalid-name\", `The name for a KindError must not include any of the following characters: \"<\", \">\", \"[\", \"]\", \"(\", \")\"`) as Rtn<TName, TContext>;\n  }\n  const partial = <const C extends AsContextShape<TContext>>(ctx: C) => {\n    return createKindError(name, { ...context, ...ctx } as MergeObjects<TContext, C>);\n  };\n\n  const pascalName = toPascalCase(name.replace(/\\//g, \"-\"));\n\n  const fn = <\n    TMsg extends string,\n    TCtx extends Record<string, unknown>,\n  >(\n    msg: TMsg,\n    ctx?: TCtx,\n  ) => {\n    const mergedContext = {\n      ...context,\n      ...(ctx || {}),\n    } as MergeObjects<TContext, TCtx>;\n\n    const err = new Error(msg) as any;\n\n    const stackTrace = getStackTrace();\n\n    err.__kind = \"KindError\";\n    err.kind = name;\n    err.type = asKindType(name);\n    err.subType = asKindSubType<TName>(name);\n    err.name = pascalName;\n    err.message = msg;\n    err.stackTrace = () => stackTrace;\n    err.stack = err.stack || \"\";\n    err.context = mergedContext;\n\n    err.toString = toStringFn(err);\n    err.toJSON = toJsonFn(err);\n\n    err[inspect.custom] = () => {\n      return err.toString();\n    };\n\n    return err;\n  };\n\n  const props = {\n    __kind: \"KindErrorType\",\n    kind: name,\n    errorName: pascalName,\n    type: asKindType(name),\n    subType: asKindSubType<TName>(name),\n    context,\n\n    proxy<\n      const E,\n      const P extends AsContextShape<TContext>,\n    >(\n      e: E,\n      ...args: [props?: P]\n    ) {\n      const props = args[0];\n      if (isKindError(e)) {\n        return e as unknown as KindError<\n          TName,\n          string,\n          ResolveContext<TContext, P>\n        > & Record<\"underlying\", E>;\n      }\n\n      let msg = \"Unknown Error\";\n      let stack: KindStackItem[] | undefined;\n\n      if (isError(e)) {\n        msg = e.message;\n        if (e.stack) {\n          stack = createStackTrace(e);\n        }\n      }\n      else if (isObject(e)) {\n        msg = getMessageInObject(e, \"message\", \"msg\", \"error\", \"cause\", \"reason\", \"err\", \"code\") || \"Unknown Error\";\n      }\n      else if (isString(e)) {\n        msg = e;\n      }\n\n      const mergedProps = {\n        ...(props || {}),\n        underlying: e,\n      };\n\n      const err = fn(msg, mergedProps);\n\n      if (stack) {\n        err.stackTrace = () => stack!;\n      }\n\n      return err as unknown as KindError<TName, string, ResolveContext<TContext, P>> & Record<\"underlying\", E>;\n    },\n\n    partial,\n\n    is(val: unknown): val is KindError<TName, string, TContext> {\n      return isKindError(val) && val.kind === name;\n    },\n\n    toString() {\n      return `KindErrorType::${pascalName}(${name})`;\n    },\n\n    toJSON() {\n      return {\n        __kind: \"KindErrorType\",\n        kind: name,\n        name: `${pascalName}ErrorType`,\n        errorName: pascalName,\n        type: asKindType(name),\n        subType: asKindSubType(name),\n        context,\n      };\n    },\n  };\n\n  const namedFn = renameFunction(fn, `${pascalName}ErrorType`);\n\n  return createFnWithProps(namedFn, props as any) as unknown as Rtn<TName, TContext>;\n}\n","import type {\n  Concat,\n  KebabCase,\n  Split,\n} from \"inferred-types/types\";\nimport type { PascalName } from \"~/types\";\n\nexport const KindErrorSymbol = \"__kind\";\n\n/**\n * a type utility which produces the _type_ for the `name` property\n * of a `KindErrorType`'s constructor function.\n */\nexport type KindErrorTypeName<\n  T extends string,\n> = PascalName<Split<T, \"/\">> extends readonly string[]\n  ? Concat<[...PascalName<Split<T, \"/\">>, \"ErrorType\"]>\n  : never;\n\nexport type KindErrorName<\n  T extends string,\n> = PascalName<Split<T, \"/\">> extends readonly string[]\n  ? Concat<PascalName<Split<T, \"/\">>>\n  : never;\n\n/**\n * a type utility which produces the _type_ for the `type` property\n * of a `KindError`.\n */\nexport type KindErrorTypeProp<\n  T extends string,\n> = string extends T\n  ? string\n  : Split<T, \"/\"> extends readonly string[]\n    ? KebabCase<Split<T, \"/\">[0]>\n    : never;\n\n/**\n * a type utility which produces the _type_ for the `type` property\n * of a `KindError`.\n */\nexport type KindErrorSubTypeProp<\n  T extends string,\n> = string extends T\n  ? string\n  : Split<T, \"/\"> extends readonly string[]\n    ? Split<T, \"/\">[1] extends string\n      ? KebabCase<Split<T, \"/\">[1]>\n      : undefined\n    : never;\n\nexport interface KindStackItem {\n  file: string | undefined;\n  function?: string;\n  args?: any[];\n  col?: number;\n  line?: number;\n  raw?: string;\n}\n\n/**\n * A Base Javascript Error\n */\nexport type JsError = Error & {\n  name: string;\n  message: string;\n  stack?: string;\n\n  toString: () => string;\n};\n\n/**\n * an _failed_ network response from the native **fetch** method.\n */\nexport type FetchError = Response & {\n  ok: false;\n};\n\nexport type FetchSuccess = Response & {\n  ok: true;\n};\n"],"mappings":"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"}