@highstate/designer 0.19.1 → 0.20.0

package/.output/server/node_modules/is-what/dist/index.js

@@ -1,171 +1,43 @@
-function getType(payload) {
-  return Object.prototype.toString.call(payload).slice(8, -1);
-}
-
-function isAnyObject(payload) {
-  return getType(payload) === "Object";
-}
-
-function isArray(payload) {
-  return getType(payload) === "Array";
-}
-
-function isBlob(payload) {
-  return getType(payload) === "Blob";
-}
-
-function isBoolean(payload) {
-  return getType(payload) === "Boolean";
-}
-
-function isDate(payload) {
-  return getType(payload) === "Date" && !isNaN(payload);
-}
-
-function isEmptyArray(payload) {
-  return isArray(payload) && payload.length === 0;
-}
-
-function isPlainObject(payload) {
-  if (getType(payload) !== "Object")
-    return false;
-  const prototype = Object.getPrototypeOf(payload);
-  return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
-}
-
-function isEmptyObject(payload) {
-  return isPlainObject(payload) && Object.keys(payload).length === 0;
-}
-
-function isEmptyString(payload) {
-  return payload === "";
-}
-
-function isError(payload) {
-  return getType(payload) === "Error" || payload instanceof Error;
-}
-
-function isFile(payload) {
-  return getType(payload) === "File";
-}
-
-function isFullArray(payload) {
-  return isArray(payload) && payload.length > 0;
-}
-
-function isFullObject(payload) {
-  return isPlainObject(payload) && Object.keys(payload).length > 0;
-}
-
-function isString(payload) {
-  return getType(payload) === "String";
-}
-
-function isFullString(payload) {
-  return isString(payload) && payload !== "";
-}
-
-function isFunction(payload) {
-  return typeof payload === "function";
-}
-
-function isType(payload, type) {
-  if (!(type instanceof Function)) {
-    throw new TypeError("Type must be a function");
-  }
-  if (!Object.prototype.hasOwnProperty.call(type, "prototype")) {
-    throw new TypeError("Type is not a class");
-  }
-  const name = type.name;
-  return getType(payload) === name || Boolean(payload && payload.constructor === type);
-}
-
-function isInstanceOf(value, classOrClassName) {
-  if (typeof classOrClassName === "function") {
-    for (let p = value; p; p = Object.getPrototypeOf(p)) {
-      if (isType(p, classOrClassName)) {
-        return true;
-      }
-    }
-    return false;
-  } else {
-    for (let p = value; p; p = Object.getPrototypeOf(p)) {
-      if (getType(p) === classOrClassName) {
-        return true;
-      }
-    }
-    return false;
-  }
-}
-
-function isMap(payload) {
-  return getType(payload) === "Map";
-}
-
-function isNaNValue(payload) {
-  return getType(payload) === "Number" && isNaN(payload);
-}
-
-function isNumber(payload) {
-  return getType(payload) === "Number" && !isNaN(payload);
-}
-
-function isNegativeNumber(payload) {
-  return isNumber(payload) && payload < 0;
-}
-
-function isNull(payload) {
-  return getType(payload) === "Null";
-}
-
-function isOneOf(a, b, c, d, e) {
-  return (value) => a(value) || b(value) || !!c && c(value) || !!d && d(value) || !!e && e(value);
-}
-
-function isUndefined(payload) {
-  return getType(payload) === "Undefined";
-}
-
-const isNullOrUndefined = isOneOf(isNull, isUndefined);
-
-function isObject(payload) {
-  return isPlainObject(payload);
-}
-
-function isObjectLike(payload) {
-  return isAnyObject(payload);
-}
-
-function isPositiveNumber(payload) {
-  return isNumber(payload) && payload > 0;
-}
-
-function isSymbol(payload) {
-  return getType(payload) === "Symbol";
-}
-
-function isPrimitive(payload) {
-  return isBoolean(payload) || isNull(payload) || isUndefined(payload) || isNumber(payload) || isString(payload) || isSymbol(payload);
-}
-
-function isPromise(payload) {
-  return getType(payload) === "Promise";
-}
-
-function isRegExp(payload) {
-  return getType(payload) === "RegExp";
-}
-
-function isSet(payload) {
-  return getType(payload) === "Set";
-}
-
-function isWeakMap(payload) {
-  return getType(payload) === "WeakMap";
-}
-
-function isWeakSet(payload) {
-  return getType(payload) === "WeakSet";
-}
-
-export { getType, isAnyObject, isArray, isBlob, isBoolean, isDate, isEmptyArray, isEmptyObject, isEmptyString, isError, isFile, isFullArray, isFullObject, isFullString, isFunction, isInstanceOf, isMap, isNaNValue, isNegativeNumber, isNull, isNullOrUndefined, isNumber, isObject, isObjectLike, isOneOf, isPlainObject, isPositiveNumber, isPrimitive, isPromise, isRegExp, isSet, isString, isSymbol, isType, isUndefined, isWeakMap, isWeakSet };
+export { getType } from './getType.js';
+export { isAnyObject } from './isAnyObject.js';
+export { isArray } from './isArray.js';
+export { isBigInt } from './isBigInt.js';
+export { isBlob } from './isBlob.js';
+export { isBoolean } from './isBoolean.js';
+export { isDate } from './isDate.js';
+export { isEmptyArray } from './isEmptyArray.js';
+export { isEmptyObject } from './isEmptyObject.js';
+export { isEmptyString } from './isEmptyString.js';
+export { isError } from './isError.js';
+export { isFile } from './isFile.js';
+export { isFullArray } from './isFullArray.js';
+export { isFullObject } from './isFullObject.js';
+export { isFullString } from './isFullString.js';
+export { isFunction } from './isFunction.js';
+export { isHexDecimal } from './isHexDecimal.js';
+export { isInstanceOf } from './isInstanceOf.js';
+export { isInteger } from './isInteger.js';
+export { isIterable } from './isIterable.js';
+export { isMap } from './isMap.js';
+export { isNaNValue } from './isNaNValue.js';
+export { isNegativeInteger } from './isNegativeInteger.js';
+export { isNegativeNumber } from './isNegativeNumber.js';
+export { isNull } from './isNull.js';
+export { isNullOrUndefined } from './isNullOrUndefined.js';
+export { isNumber } from './isNumber.js';
+export { isObject } from './isObject.js';
+export { isObjectLike } from './isObjectLike.js';
+export { isOneOf } from './isOneOf.js';
+export { isPlainObject } from './isPlainObject.js';
+export { isPositiveInteger } from './isPositiveInteger.js';
+export { isPositiveNumber } from './isPositiveNumber.js';
+export { isPrimitive } from './isPrimitive.js';
+export { isPromise } from './isPromise.js';
+export { isRegExp } from './isRegExp.js';
+export { isSet } from './isSet.js';
+export { isString } from './isString.js';
+export { isSymbol } from './isSymbol.js';
+export { isType } from './isType.js';
+export { isUndefined } from './isUndefined.js';
+export { isWeakMap } from './isWeakMap.js';
+export { isWeakSet } from './isWeakSet.js';

package/.output/server/node_modules/is-what/dist/isAnyObject.js

@@ -0,0 +1,8 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is an any kind of object (including special classes or objects with
+ * different prototypes)
+ */
+export function isAnyObject(payload) {
+    return getType(payload) === 'Object';
+}

package/.output/server/node_modules/is-what/dist/isArray.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an array */
+export function isArray(payload) {
+    return getType(payload) === 'Array';
+}

package/.output/server/node_modules/is-what/dist/isBigInt.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a bigint */
+export function isBigInt(payload) {
+    return getType(payload) === 'BigInt';
+}

package/.output/server/node_modules/is-what/dist/isBlob.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Blob */
+export function isBlob(payload) {
+    return getType(payload) === 'Blob';
+}

package/.output/server/node_modules/is-what/dist/isBoolean.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a boolean */
+export function isBoolean(payload) {
+    return getType(payload) === 'Boolean';
+}

package/.output/server/node_modules/is-what/dist/isDate.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Date, and that the date is valid */
+export function isDate(payload) {
+    return getType(payload) === 'Date' && !Number.isNaN(payload.valueOf());
+}

package/.output/server/node_modules/is-what/dist/isEmptyArray.js

@@ -0,0 +1,5 @@
+import { isArray } from './isArray.js';
+/** Returns whether the payload is a an empty array */
+export function isEmptyArray(payload) {
+    return isArray(payload) && payload.length === 0;
+}

package/.output/server/node_modules/is-what/dist/isEmptyObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export function isEmptyObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length === 0;
+}

package/.output/server/node_modules/is-what/dist/isEmptyString.js

@@ -0,0 +1,4 @@
+/** Returns whether the payload is '' */
+export function isEmptyString(payload) {
+    return payload === '';
+}

package/.output/server/node_modules/is-what/dist/isError.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an Error */
+export function isError(payload) {
+    return getType(payload) === 'Error' || payload instanceof Error;
+}

package/.output/server/node_modules/is-what/dist/isFile.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a File */
+export function isFile(payload) {
+    return getType(payload) === 'File';
+}

package/.output/server/node_modules/is-what/dist/isFullArray.js

@@ -0,0 +1,5 @@
+import { isArray } from './isArray.js';
+/** Returns whether the payload is a an array with at least 1 item */
+export function isFullArray(payload) {
+    return isArray(payload) && payload.length > 0;
+}

package/.output/server/node_modules/is-what/dist/isFullObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a an empty object (excluding special classes or objects with other
+ * prototypes)
+ */
+export function isFullObject(payload) {
+    return isPlainObject(payload) && Object.keys(payload).length > 0;
+}

package/.output/server/node_modules/is-what/dist/isFullString.js

@@ -0,0 +1,5 @@
+import { isString } from './isString.js';
+/** Returns whether the payload is a string, BUT returns false for '' */
+export function isFullString(payload) {
+    return isString(payload) && payload !== '';
+}

package/.output/server/node_modules/is-what/dist/isFunction.js

@@ -0,0 +1,4 @@
+/** Returns whether the payload is a function (regular or async) */
+export function isFunction(payload) {
+    return typeof payload === 'function';
+}

package/.output/server/node_modules/is-what/dist/isHexDecimal.js

@@ -0,0 +1,12 @@
+import { isString } from './isString.js';
+/**
+ * Checks if a string is a valid hexadecimal string. If a length is provided, it also checks that
+ * the string has that length.
+ */
+export function isHexDecimal(payload, length) {
+    if (!isString(payload))
+        return false;
+    if (!/^[0-9a-fA-F]+$/.test(payload))
+        return false;
+    return length === undefined || payload.length === length;
+}

package/.output/server/node_modules/is-what/dist/isInstanceOf.js

@@ -0,0 +1,19 @@
+import { getType } from './getType.js';
+import { isType } from './isType.js';
+export function isInstanceOf(value, classOrClassName) {
+    if (typeof classOrClassName === 'function') {
+        for (let p = value; p; p = Object.getPrototypeOf(p)) {
+            if (isType(p, classOrClassName)) {
+                return true;
+            }
+        }
+    }
+    else {
+        for (let p = value; p; p = Object.getPrototypeOf(p)) {
+            if (getType(p) === classOrClassName) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/.output/server/node_modules/is-what/dist/isInteger.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is an integer number */
+export function isInteger(payload) {
+    return getType(payload) === 'Number' && Number.isInteger(payload);
+}

package/.output/server/node_modules/is-what/dist/isIterable.js

@@ -0,0 +1,16 @@
+/** Returns whether the payload is an iterable (regular or async) */
+export function isIterable(payload) {
+    // oxlint-disable-next-line no-typeof-undefined
+    if (typeof Symbol === 'undefined' || typeof Symbol.iterator === 'undefined') {
+        return false;
+    }
+    // oxlint-disable-next-line no-null
+    if (payload === null || payload === undefined)
+        return false;
+    // Strings are iterable, even though they're primitives.
+    if (typeof payload === 'string')
+        return true;
+    // For objects, arrays and functions, check if Symbol.iterator is a function.
+    return ((typeof payload === 'object' || typeof payload === 'function') &&
+        typeof payload[Symbol.iterator] === 'function');
+}

package/.output/server/node_modules/is-what/dist/isMap.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Map */
+export function isMap(payload) {
+    return getType(payload) === 'Map';
+}

package/.output/server/node_modules/is-what/dist/isNaNValue.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is literally the value `NaN` (it's `NaN` and also a `number`) */
+export function isNaNValue(payload) {
+    return getType(payload) === 'Number' && Number.isNaN(payload);
+}

package/.output/server/node_modules/is-what/dist/isNegativeInteger.js

@@ -0,0 +1,5 @@
+import { isInteger } from './isInteger.js';
+/** Returns whether the payload is a negative Integer (but not 0) */
+export function isNegativeInteger(payload) {
+    return isInteger(payload) && payload < 0;
+}

package/.output/server/node_modules/is-what/dist/isNegativeNumber.js

@@ -0,0 +1,5 @@
+import { isNumber } from './isNumber.js';
+/** Returns whether the payload is a negative number (but not 0) */
+export function isNegativeNumber(payload) {
+    return isNumber(payload) && payload < 0;
+}

package/.output/server/node_modules/is-what/dist/isNull.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is null */
+export function isNull(payload) {
+    return getType(payload) === 'Null';
+}

package/.output/server/node_modules/is-what/dist/isNullOrUndefined.js

@@ -0,0 +1,5 @@
+import { isNull } from './isNull.js';
+import { /* tree-shaking no-side-effects-when-called */ isOneOf } from './isOneOf.js';
+import { isUndefined } from './isUndefined.js';
+/** Returns true whether the payload is null or undefined */
+export const isNullOrUndefined = isOneOf(isNull, isUndefined);

package/.output/server/node_modules/is-what/dist/isNumber.js

@@ -0,0 +1,9 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is a number (but not NaN)
+ *
+ * This will return `false` for `NaN`!!
+ */
+export function isNumber(payload) {
+    return getType(payload) === 'Number' && !Number.isNaN(payload);
+}

package/.output/server/node_modules/is-what/dist/isObject.js

@@ -0,0 +1,8 @@
+import { isPlainObject } from './isPlainObject.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export function isObject(payload) {
+    return isPlainObject(payload);
+}

package/.output/server/node_modules/is-what/dist/isObjectLike.js

@@ -0,0 +1,11 @@
+import { isAnyObject } from './isAnyObject.js';
+/**
+ * Returns whether the payload is an object like a type passed in < >
+ *
+ * Usage: isObjectLike<{id: any}>(payload) // will make sure it's an object and has an `id` prop.
+ *
+ * @template T This must be passed in < >
+ */
+export function isObjectLike(payload) {
+    return isAnyObject(payload);
+}

package/.output/server/node_modules/is-what/dist/isOneOf.js

@@ -0,0 +1,15 @@
+/**
+ * A factory function that creates a function to check if the payload is one of the given types.
+ *
+ * @example
+ *   import { isOneOf, isNull, isUndefined } from 'is-what'
+ *
+ *   const isNullOrUndefined = isOneOf(isNull, isUndefined)
+ *
+ *   isNullOrUndefined(null) // true
+ *   isNullOrUndefined(undefined) // true
+ *   isNullOrUndefined(123) // false
+ */
+export function isOneOf(a, b, c, d, e) {
+    return (value) => a(value) || b(value) || (!!c && c(value)) || (!!d && d(value)) || (!!e && e(value));
+}

package/.output/server/node_modules/is-what/dist/isPlainObject.js

@@ -0,0 +1,11 @@
+import { getType } from './getType.js';
+/**
+ * Returns whether the payload is a plain JavaScript object (excluding special classes or objects
+ * with other prototypes)
+ */
+export function isPlainObject(payload) {
+    if (getType(payload) !== 'Object')
+        return false;
+    const prototype = Object.getPrototypeOf(payload);
+    return !!prototype && prototype.constructor === Object && prototype === Object.prototype;
+}

package/.output/server/node_modules/is-what/dist/isPositiveInteger.js

@@ -0,0 +1,5 @@
+import { isInteger } from './isInteger.js';
+/** Returns whether the payload is a positive Integer (but not 0) */
+export function isPositiveInteger(payload) {
+    return isInteger(payload) && payload > 0;
+}

package/.output/server/node_modules/is-what/dist/isPositiveNumber.js

@@ -0,0 +1,5 @@
+import { isNumber } from './isNumber.js';
+/** Returns whether the payload is a positive number (but not 0) */
+export function isPositiveNumber(payload) {
+    return isNumber(payload) && payload > 0;
+}

package/.output/server/node_modules/is-what/dist/isPrimitive.js

@@ -0,0 +1,21 @@
+import { isBigInt } from './isBigInt.js';
+import { isBoolean } from './isBoolean.js';
+import { isNull } from './isNull.js';
+import { isNumber } from './isNumber.js';
+import { isString } from './isString.js';
+import { isSymbol } from './isSymbol.js';
+import { isUndefined } from './isUndefined.js';
+/**
+ * Returns whether the payload is a primitive type (eg. Boolean | Null | Undefined | Number | String
+ *
+ * | Symbol)
+ */
+export function isPrimitive(payload) {
+    return (isBoolean(payload) ||
+        isNull(payload) ||
+        isUndefined(payload) ||
+        isNumber(payload) ||
+        isString(payload) ||
+        isSymbol(payload) ||
+        isBigInt(payload));
+}

package/.output/server/node_modules/is-what/dist/isPromise.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Promise */
+export function isPromise(payload) {
+    return getType(payload) === 'Promise';
+}

package/.output/server/node_modules/is-what/dist/isRegExp.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a regular expression (RegExp) */
+export function isRegExp(payload) {
+    return getType(payload) === 'RegExp';
+}

package/.output/server/node_modules/is-what/dist/isSet.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Set */
+export function isSet(payload) {
+    return getType(payload) === 'Set';
+}

package/.output/server/node_modules/is-what/dist/isString.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a string */
+export function isString(payload) {
+    return getType(payload) === 'String';
+}

package/.output/server/node_modules/is-what/dist/isSymbol.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a Symbol */
+export function isSymbol(payload) {
+    return getType(payload) === 'Symbol';
+}

package/.output/server/node_modules/is-what/dist/isType.js

@@ -0,0 +1,20 @@
+import { getType } from './getType.js';
+import { isFunction } from './isFunction.js';
+/**
+ * Does a generic check to check that the given payload is of a given type. In cases like Number, it
+ * will return true for NaN as NaN is a Number (thanks javascript!); It will, however, differentiate
+ * between object and null
+ *
+ * @throws {TypeError} Will throw type error if type is an invalid type
+ */
+export function isType(payload, type) {
+    if (!isFunction(type)) {
+        throw new TypeError('Type must be a function');
+    }
+    if (!Object.hasOwn(type, 'prototype')) {
+        throw new TypeError('Type is not a class');
+    }
+    // Classes usually have names (as functions usually have names)
+    const { name } = type;
+    return getType(payload) === name || Boolean(payload && payload.constructor === type);
+}

package/.output/server/node_modules/is-what/dist/isUndefined.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is undefined */
+export function isUndefined(payload) {
+    return getType(payload) === 'Undefined';
+}

package/.output/server/node_modules/is-what/dist/isWeakMap.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a WeakMap */
+export function isWeakMap(payload) {
+    return getType(payload) === 'WeakMap';
+}

package/.output/server/node_modules/is-what/dist/isWeakSet.js

@@ -0,0 +1,5 @@
+import { getType } from './getType.js';
+/** Returns whether the payload is a WeakSet */
+export function isWeakSet(payload) {
+    return getType(payload) === 'WeakSet';
+}