@chainflip/utils 0.1.0

package/dist/chunk-NYJKCZRI.js

@@ -0,0 +1,52 @@
+import {
+  isBigInt,
+  isBoolean,
+  isNumber,
+  isObject,
+  isString,
+  isSymbol,
+  isUndefined
+} from "./chunk-CZNX6EUV.js";
+
+// src/assertion.ts
+function assert(condition, message = "assertion failed", Constructor = Error) {
+  if (!condition) {
+    throw new Constructor(message);
+  }
+}
+function assertString(value, message) {
+  assert(isString(value), message ?? `expected a "string", got "${typeof value}"`);
+}
+function assertNumber(value, message) {
+  assert(isNumber(value), message ?? `expected a "number", got "${typeof value}"`);
+}
+function assertBigInt(value, message) {
+  assert(isBigInt(value), message ?? `expected a "bigint", got "${typeof value}"`);
+}
+function assertBoolean(value, message) {
+  assert(isBoolean(value), message ?? `expected a "boolean", got "${typeof value}"`);
+}
+function assertSymbol(value, message) {
+  assert(isSymbol(value), message ?? `expected a "symbol", got "${typeof value}"`);
+}
+function assertObject(value, message) {
+  assert(isObject(value), message ?? `expected an "object", got "${typeof value}"`);
+}
+function assertUndefined(value, message) {
+  assert(isUndefined(value), message ?? `expected "undefined", got "${typeof value}"`);
+}
+var unreachable = (x, message = "unreachable") => {
+  throw new Error(message);
+};
+
+export {
+  assert,
+  assertString,
+  assertNumber,
+  assertBigInt,
+  assertBoolean,
+  assertSymbol,
+  assertObject,
+  assertUndefined,
+  unreachable
+};

package/dist/guard.cjs

@@ -0,0 +1,55 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/guard.ts
+var guard_exports = {};
+__export(guard_exports, {
+  isBigInt: () => isBigInt,
+  isBoolean: () => isBoolean,
+  isNotNullish: () => isNotNullish,
+  isNullish: () => isNullish,
+  isNumber: () => isNumber,
+  isObject: () => isObject,
+  isString: () => isString,
+  isSymbol: () => isSymbol,
+  isUndefined: () => isUndefined
+});
+module.exports = __toCommonJS(guard_exports);
+var createIsGuard = (type) => (value) => typeof value === type;
+var isString = createIsGuard("string");
+var isNumber = createIsGuard("number");
+var isBigInt = createIsGuard("bigint");
+var isBoolean = createIsGuard("boolean");
+var isSymbol = createIsGuard("symbol");
+var isObject = createIsGuard("object");
+var isUndefined = createIsGuard("undefined");
+var isNotNullish = (value) => value != null;
+var isNullish = (value) => value == null;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isBigInt,
+  isBoolean,
+  isNotNullish,
+  isNullish,
+  isNumber,
+  isObject,
+  isString,
+  isSymbol,
+  isUndefined
+});

package/dist/guard.d.cts

@@ -0,0 +1,20 @@
+type TypeMap = {
+    string: string;
+    number: number;
+    bigint: bigint;
+    boolean: boolean;
+    symbol: symbol;
+    object: object;
+    undefined: undefined;
+};
+declare const isString: (value: unknown) => value is string;
+declare const isNumber: (value: unknown) => value is number;
+declare const isBigInt: (value: unknown) => value is bigint;
+declare const isBoolean: (value: unknown) => value is boolean;
+declare const isSymbol: (value: unknown) => value is symbol;
+declare const isObject: (value: unknown) => value is object;
+declare const isUndefined: (value: unknown) => value is undefined;
+declare const isNotNullish: <T>(value: T) => value is NonNullable<T>;
+declare const isNullish: (value: unknown) => value is null | undefined;
+
+export { type TypeMap, isBigInt, isBoolean, isNotNullish, isNullish, isNumber, isObject, isString, isSymbol, isUndefined };

package/dist/guard.d.ts

@@ -0,0 +1,20 @@
+type TypeMap = {
+    string: string;
+    number: number;
+    bigint: bigint;
+    boolean: boolean;
+    symbol: symbol;
+    object: object;
+    undefined: undefined;
+};
+declare const isString: (value: unknown) => value is string;
+declare const isNumber: (value: unknown) => value is number;
+declare const isBigInt: (value: unknown) => value is bigint;
+declare const isBoolean: (value: unknown) => value is boolean;
+declare const isSymbol: (value: unknown) => value is symbol;
+declare const isObject: (value: unknown) => value is object;
+declare const isUndefined: (value: unknown) => value is undefined;
+declare const isNotNullish: <T>(value: T) => value is NonNullable<T>;
+declare const isNullish: (value: unknown) => value is null | undefined;
+
+export { type TypeMap, isBigInt, isBoolean, isNotNullish, isNullish, isNumber, isObject, isString, isSymbol, isUndefined };

package/dist/guard.js

@@ -0,0 +1,22 @@
+import {
+  isBigInt,
+  isBoolean,
+  isNotNullish,
+  isNullish,
+  isNumber,
+  isObject,
+  isString,
+  isSymbol,
+  isUndefined
+} from "./chunk-CZNX6EUV.js";
+export {
+  isBigInt,
+  isBoolean,
+  isNotNullish,
+  isNullish,
+  isNumber,
+  isObject,
+  isString,
+  isSymbol,
+  isUndefined
+};