@domql/utils 2.5.187 → 3.0.0

package/dist/esm/props.js

@@ -0,0 +1,216 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+import { DOMQ_PROPERTIES, PROPS_METHODS } from "./keys.js";
+import { addEventFromProps } from "./events.js";
+import { deepClone, deepMerge, exec } from "./object.js";
+import { is, isArray, isFunction, isObject, isObjectLike } from "./types.js";
+const createProps = (element, parent, key) => {
+  const { props, __ref: ref } = element;
+  ref.__propsStack = [];
+  if (props) ref.__initialProps = props;
+  else return {};
+  if (!isObjectLike(props)) {
+    ref.__propsStack.push(props);
+    return {};
+  }
+  return __spreadValues({}, props);
+};
+function pickupPropsFromElement(element, opts = {}) {
+  var _a, _b, _c;
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in element) {
+    const value = element[key];
+    const hasDefine = isObject((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = isObject((_c = (_b = element.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
+    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
+    const isBuiltin = DOMQ_PROPERTIES.includes(key);
+    if (!isElement && !isBuiltin && !hasDefine && !hasGlobalDefine) {
+      element.props[key] = value;
+      delete element[key];
+      cachedKeys.push(key);
+    }
+  }
+  return element;
+}
+function pickupElementFromProps(element, opts) {
+  var _a, _b, _c;
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in element.props) {
+    const value = element.props[key];
+    const isEvent = key.startsWith("on") && key.length > 2;
+    const isFn = isFunction(value);
+    if (isEvent && isFn) {
+      addEventFromProps(key, element);
+      delete element.props[key];
+      continue;
+    }
+    if (cachedKeys.includes(key)) continue;
+    const hasDefine = isObject((_a = element.define) == null ? void 0 : _a[key]);
+    const hasGlobalDefine = isObject((_c = (_b = element.context) == null ? void 0 : _b.define) == null ? void 0 : _c[key]);
+    const isElement = /^[A-Z]/.test(key) || /^\d+$/.test(key);
+    const isBuiltin = DOMQ_PROPERTIES.includes(key);
+    if (isElement || isBuiltin || hasDefine || hasGlobalDefine) {
+      element[key] = value;
+      delete element.props[key];
+    }
+  }
+  return element;
+}
+function propertizeElement(element, opts = {}) {
+  const cachedKeys = [];
+  pickupPropsFromElement(element, { cachedKeys });
+  pickupElementFromProps(element, { cachedKeys });
+  return element;
+}
+const objectizeStringProperty = (propValue) => {
+  if (is(propValue)("string", "number")) {
+    return { inheritedString: propValue };
+  }
+  return propValue;
+};
+const propExists = (prop, stack) => {
+  if (!prop || !stack.length) return false;
+  const key = isObject(prop) ? JSON.stringify(prop) : prop;
+  return stack.some((existing) => {
+    const existingKey = isObject(existing) ? JSON.stringify(existing) : existing;
+    return existingKey === key;
+  });
+};
+const inheritParentProps = (element, parent) => {
+  var _a;
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  const parentProps = parent.props;
+  if (!parentProps) return propsStack;
+  const matchParentKeyProps = parentProps[element.key];
+  const matchParentChildProps = parentProps.childProps;
+  const ignoreChildProps = (_a = element.props) == null ? void 0 : _a.ignoreChildProps;
+  if (matchParentChildProps && !ignoreChildProps) {
+    const childProps = objectizeStringProperty(matchParentChildProps);
+    propsStack.unshift(childProps);
+  }
+  if (matchParentKeyProps) {
+    const keyProps = objectizeStringProperty(matchParentKeyProps);
+    propsStack.unshift(keyProps);
+  }
+  return propsStack;
+};
+async function update(props, options) {
+  const element = this.__element;
+  await element.update({ props }, options);
+}
+function setPropsPrototype(element) {
+  const methods = { update: update.bind(element.props), __element: element };
+  Object.setPrototypeOf(element.props, methods);
+}
+const removeDuplicateProps = (propsStack) => {
+  const seen = /* @__PURE__ */ new Set();
+  return propsStack.filter((prop) => {
+    if (!prop || PROPS_METHODS.includes(prop)) return false;
+    const key = isObject(prop) ? JSON.stringify(prop) : prop;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+const syncProps = (propsStack, element, opts) => {
+  element.props = propsStack.reduce((mergedProps, v) => {
+    if (PROPS_METHODS.includes(v)) return mergedProps;
+    while (isFunction(v)) v = exec(v, element);
+    return deepMerge(mergedProps, deepClone(v, { exclude: PROPS_METHODS }));
+  }, {});
+  setPropsPrototype(element);
+  return element.props;
+};
+const createPropsStack = (element, parent) => {
+  const { props, __ref: ref } = element;
+  let propsStack = ref.__propsStack || [];
+  if (parent && parent.props) {
+    const parentStack = inheritParentProps(element, parent);
+    propsStack = [...parentStack];
+  }
+  if (isObject(props)) propsStack.push(props);
+  else if (props === "inherit" && (parent == null ? void 0 : parent.props)) propsStack.push(parent.props);
+  else if (props) propsStack.push(props);
+  if (isArray(ref.__extendsStack)) {
+    ref.__extendsStack.forEach((_extends) => {
+      if (_extends.props && _extends.props !== props) {
+        propsStack.push(_extends.props);
+      }
+    });
+  }
+  ref.__propsStack = removeDuplicateProps(propsStack);
+  return ref.__propsStack;
+};
+const applyProps = (element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = createPropsStack(element, parent);
+  if (propsStack.length) {
+    syncProps(propsStack, element);
+  } else {
+    ref.__propsStack = [];
+    element.props = {};
+  }
+};
+const initProps = function(element, parent, options) {
+  const { __ref: ref } = element;
+  if (ref.__if) applyProps(element, parent);
+  else {
+    try {
+      applyProps(element, parent);
+    } catch (e) {
+      element.props = {};
+      ref.__propsStack = [];
+    }
+  }
+  setPropsPrototype(element);
+  return element;
+};
+const updateProps = (newProps, element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  let newStack = [...propsStack];
+  const parentProps = inheritParentProps(element, parent);
+  if (parentProps.length) {
+    newStack = [...parentProps, ...newStack];
+  }
+  if (newProps) {
+    newStack = [newProps, ...newStack];
+  }
+  ref.__propsStack = removeDuplicateProps(newStack);
+  if (ref.__propsStack.length) {
+    syncProps(ref.__propsStack, element);
+  }
+  return element;
+};
+export {
+  applyProps,
+  createProps,
+  createPropsStack,
+  inheritParentProps,
+  initProps,
+  objectizeStringProperty,
+  pickupElementFromProps,
+  pickupPropsFromElement,
+  propExists,
+  propertizeElement,
+  removeDuplicateProps,
+  setPropsPrototype,
+  syncProps,
+  update,
+  updateProps
+};

package/dist/esm/scope.js

@@ -0,0 +1,8 @@
+const createScope = (element, parent) => {
+  var _a;
+  const { __ref: ref } = element;
+  if (!element.scope) element.scope = parent.scope || ((_a = ref.root) == null ? void 0 : _a.scope) || {};
+};
+export {
+  createScope
+};

package/dist/esm/state.js

@@ -0,0 +1,185 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+import { addProtoToArray } from "./array.js";
+import { STATE_METHODS } from "./keys.js";
+import {
+  deepClone,
+  deepMerge,
+  execPromise,
+  overwriteDeep,
+  overwriteShallow
+} from "./object.js";
+import {
+  is,
+  isFunction,
+  isObject,
+  isObjectLike,
+  isString,
+  isUndefined
+} from "./types.js";
+const checkForStateTypes = async (element) => {
+  const { state: orig, props, __ref: ref } = element;
+  const state = (props == null ? void 0 : props.state) || orig;
+  if (isFunction(state)) {
+    ref.__state = state;
+    return await execPromise(state, element);
+  } else if (is(state)("string", "number")) {
+    ref.__state = state;
+    return { value: state };
+  } else if (state === true) {
+    ref.__state = element.key;
+    return {};
+  } else if (state) {
+    ref.__hasRootState = true;
+    return state;
+  } else {
+    return false;
+  }
+};
+const getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/")) return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1) return parentState.root;
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../")) return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent) return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = isString(stateKey) ? stateKey.split("/") : [stateKey];
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+    let childInParent = parentState[childKey];
+    if (!childInParent) childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent) return parentState;
+  return parentState[stateKey];
+};
+const findInheritedState = (element, parent, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element)) return;
+  const rootState = getRootStateInKey(stateKey, parent.state);
+  let parentState = parent.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState) return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+const createInheritedState = (element, parent) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent);
+  if (isUndefined(inheritedState)) return element.state;
+  if (is(inheritedState)("object", "array")) {
+    return deepClone(inheritedState);
+  } else if (is(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const { __ref: ref } = element;
+  const stateKey = ref == null ? void 0 : ref.__state;
+  if (stateKey && is(stateKey)("number", "string", "boolean")) return true;
+  return false;
+};
+const isState = function(state) {
+  if (!isObjectLike(state)) return false;
+  return Boolean(
+    state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.keys && state.values && state.toggle && state.replace && state.quietUpdate && state.quietReplace && state.add && state.apply && state.applyReplace && state.setByPath && state.setPathCollection && state.removeByPath && state.removePathCollection && state.getByPath && state.applyFunction && state.__element && state.__children
+  );
+};
+const createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys = path.split("/");
+  const obj = {};
+  let ref = obj;
+  keys.forEach((key, index) => {
+    ref[key] = index === keys.length - 1 ? value || {} : {};
+    ref = ref[key];
+  });
+  return obj;
+};
+const applyDependentState = async (element, state) => {
+  const { __element } = state;
+  const origState = await execPromise(__element == null ? void 0 : __element.state, element);
+  if (!origState) return;
+  const dependentState = deepClone(origState, STATE_METHODS);
+  const newDepends = { [element.key]: dependentState };
+  const __depends = isObject(origState.__depends) ? __spreadValues(__spreadValues({}, origState.__depends), newDepends) : newDepends;
+  if (Array.isArray(origState)) {
+    addProtoToArray(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), {
+      __depends
+    }));
+  } else {
+    Object.setPrototypeOf(origState, __spreadProps(__spreadValues({}, Object.getPrototypeOf(origState)), {
+      __depends
+    }));
+  }
+  return dependentState;
+};
+const overwriteState = (state, obj, options = {}) => {
+  const { overwrite } = options;
+  if (!overwrite) return;
+  const shallow = overwrite === "shallow";
+  const merge = overwrite === "merge";
+  if (merge) {
+    deepMerge(state, obj, STATE_METHODS);
+    return;
+  }
+  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+  overwriteFunc(state, obj, STATE_METHODS);
+};
+export {
+  applyDependentState,
+  checkForStateTypes,
+  checkIfInherits,
+  createInheritedState,
+  createNestedObjectByKeyPath,
+  findInheritedState,
+  getChildStateInKey,
+  getParentStateInKey,
+  getRootStateInKey,
+  isState,
+  overwriteState
+};

package/dist/esm/string.js

@@ -11,29 +11,37 @@ const trimStringFromSymbols = (str, characters) => {
   return str.replace(pattern, "");
 };
 const brackRegex = {
-  2: /\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}/g,
-  3: /\{\{\{\s*((?:\.\.\/)+)?([^}\s]+)\s*\}\}\}/g
+  2: /{{\s*((?:\.\.\/)*)([\w\d.]+)\s*}}/g,
+  3: /{{{(\s*(?:\.\.\/)*)([\w\d.]+)\s*}}}/g
 };
-function replaceLiteralsWithObjectFields(str, options = {}, forcedState) {
-  if (!str.includes(options.bracketsLength === 3 ? "{{{" : "{{"))
-    return str;
-  const reg = brackRegex[options.bracketsLength || 2];
-  const obj = forcedState || (this == null ? void 0 : this.state) || {};
+const getNestedValue = (obj, path) => {
+  return path.split(".").reduce((acc, part) => {
+    return acc && acc[part] !== void 0 ? acc[part] : void 0;
+  }, obj);
+};
+function replaceLiteralsWithObjectFields(str, state = {}, options = {}) {
+  const { bracketsLength = 2 } = options;
+  const bracketPattern = bracketsLength === 3 ? "{{{" : "{{";
+  if (!str.includes(bracketPattern)) return str;
+  const reg = brackRegex[bracketsLength];
+  const obj = state || {};
   return str.replace(reg, (_, parentPath, variable) => {
     if (parentPath) {
-      const parentLevels = parentPath.match(options.bracketsLength === 3 ? /\.\.\.\//g : /\.\.\//g).length;
+      const parentLevels = (parentPath.match(/\.\.\//g) || []).length;
       let parentState = obj;
       for (let i = 0; i < parentLevels; i++) {
+        if (!parentState || !parentState.parent) return "";
         parentState = parentState.parent;
-        if (!parentState) {
-          return "";
-        }
       }
-      const value = parentState[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const key = variable.trim();
+      if (key === "parent") {
+        return parentState.value !== void 0 ? String(parentState.value) : "";
+      }
+      const value = getNestedValue(parentState, key);
+      return value !== void 0 ? String(value) : "";
     } else {
-      const value = obj[variable.trim()];
-      return value !== void 0 ? `${value}` : "";
+      const value = getNestedValue(obj, variable.trim());
+      return value !== void 0 ? String(value) : "";
     }
   });
 }
@@ -109,7 +117,10 @@ const customEncodeURIComponent = (str) => {
   }).join("");
 };
 const customDecodeURIComponent = (encodedStr) => {
-  return encodedStr.replace(/%[0-9A-Fa-f]{2}/g, (match) => String.fromCharCode(parseInt(match.slice(1), 16)));
+  return encodedStr.replace(
+    /%[0-9A-Fa-f]{2}/g,
+    (match) => String.fromCharCode(parseInt(match.slice(1), 16))
+  );
 };
 export {
   customDecodeURIComponent,

package/dist/esm/types.js

@@ -1,7 +1,6 @@
 import { isHtmlElement, isNode } from "./node.js";
 const isObject = (arg) => {
-  if (arg === null)
-    return false;
+  if (arg === null) return false;
   return typeof arg === "object" && arg.constructor === Object;
 };
 const isString = (arg) => typeof arg === "string";
@@ -12,8 +11,7 @@ const isNull = (arg) => arg === null;
 const isArray = (arg) => Array.isArray(arg);
 const isDate = (d) => d instanceof Date;
 const isObjectLike = (arg) => {
-  if (arg === null)
-    return false;
+  if (arg === null) return false;
   return typeof arg === "object";
 };
 const isDefined = (arg) => {

package/dist/esm/update.js

@@ -0,0 +1,22 @@
+import { createSnapshotId } from "./key.js";
+const snapshot = {
+  snapshotId: createSnapshotId
+};
+const captureSnapshot = (element, options) => {
+  const ref = element.__ref;
+  const { currentSnapshot, calleeElement } = options;
+  const isCallee = calleeElement === element;
+  if (!calleeElement || isCallee) {
+    const createdStanpshot = snapshot.snapshotId();
+    ref.__currentSnapshot = createdStanpshot;
+    return [createdStanpshot, element];
+  }
+  const snapshotOnCallee = calleeElement.__ref.__currentSnapshot;
+  if (currentSnapshot < snapshotOnCallee) {
+    return [snapshotOnCallee, calleeElement, true];
+  }
+  return [snapshotOnCallee, calleeElement];
+};
+export {
+  captureSnapshot
+};

package/element.js

@@ -0,0 +1,149 @@
+'use strict'
+
+import { createExtends } from './extends.js'
+import { createKey } from './key.js'
+import { isNode } from './node.js'
+import { createProps } from './props.js'
+import { HTML_TAGS } from './tags.js'
+import { is, isFunction } from './types.js'
+
+const ENV = process.env.NODE_ENV
+
+export const returnValueAsText = (element, parent, key) => {
+  const childExtendsTag = parent.childExtends && parent.childExtends.tag
+  const childPropsTag = parent.props.childProps && parent.props.childProps.tag
+  const isKeyValidHTMLTag = HTML_TAGS.body.indexOf(key) > -1 && key
+  return {
+    text: element,
+    tag: childExtendsTag || childPropsTag || isKeyValidHTMLTag || 'string'
+  }
+}
+
+export const createBasedOnType = (element, parent, key) => {
+  // if ELEMENT is not given
+  if (element === undefined) {
+    if (ENV === 'test' || ENV === 'development') {
+      console.warn(
+        key,
+        'element is undefined in',
+        parent && parent.__ref && parent.__ref.path
+      )
+    }
+    return {}
+  }
+
+  if (element === null) return
+  if (element === true) return {}
+
+  if (is(element)('string', 'number')) {
+    return returnValueAsText(element, parent, key)
+  }
+
+  if (isFunction(element)) {
+    return { props: element }
+  }
+
+  return element
+}
+
+export const addRef = (element, parent) => {
+  const ref = {}
+  ref.origin = element
+  ref.parent = parent
+  return ref
+}
+
+export const createParent = (element, parent, key, options, root) => {
+  if (!parent) return root
+  if (isNode(parent)) {
+    const parentNodeWrapper = { key: ':root', node: parent }
+    root[`${key}_parent`] = parentNodeWrapper
+    return parentNodeWrapper
+  }
+  return parent
+}
+
+export const createRoot = (element, parent) => {
+  const { __ref: ref } = element
+  const { __ref: parentRef } = parent
+
+  const hasRoot = parent && parent.key === ':root'
+  if (!ref?.root) {
+    return hasRoot ? element : parentRef?.root
+  }
+}
+
+export const createPath = (element, parent, key) => {
+  let { __ref: parentRef } = parent
+  // set the PATH array
+  if (!parentRef) parentRef = parent.ref = {}
+  if (!parentRef.path) parentRef.path = []
+  return parentRef.path.concat(key)
+}
+
+export const addContext = (element, parent, key, options, root) => {
+  const forcedOptionsContext =
+    options.context && !root.context && !element.context
+  if (forcedOptionsContext) root.context = options.context
+
+  // inherit from parent or root
+  return options.context || parent.context || root.context || element.context
+}
+
+export const addCaching = (element, parent, key) => {
+  const ref = addRef(element, parent)
+
+  element.__ref = ref
+
+  // enable CACHING
+  if (!ref.__defineCache) ref.__defineCache = {}
+
+  // enable EXEC
+  if (!ref.__exec) ref.__exec = {}
+  if (!ref.__execProps) ref.__execProps = {}
+
+  // enable CLASS CACHING
+  if (!ref.__class) ref.__class = {}
+  if (!ref.__classNames) ref.__classNames = {}
+
+  // enable CLASS CACHING
+  if (!ref.__attr) ref.__attr = {}
+
+  // enable CHANGES storing
+  if (!ref.__changes) ref.__changes = []
+
+  // enable CHANGES storing
+  if (!ref.__children) ref.__children = []
+
+  ref.__extends = createExtends(element, parent, key)
+  ref.path = createPath(element, parent, key)
+  ref.root = createRoot(element, parent) // Call createRoot after addCaching
+
+  return ref
+}
+
+export const createElement = (passedProps, parentEl, passedKey, opts, root) => {
+  const hashed = passedProps?.__hash
+  const element = hashed
+    ? { extends: [passedProps] }
+    : createBasedOnType(passedProps, parentEl, passedKey)
+  if (!element) return
+
+  const parent = createParent(element, parentEl, passedKey, opts, root)
+  const key = createKey(element, parent, passedKey)
+
+  addCaching(element, parent, key)
+
+  const props = createProps(element, parent, key)
+  const context = addContext(element, parent, key, opts, root)
+  const on = element.on || {}
+
+  return {
+    ...element,
+    key,
+    props,
+    parent,
+    context,
+    on
+  }
+}

package/env.js

@@ -2,9 +2,12 @@
 
 export const NODE_ENV = process.env.NODE_ENV
 
-export const isProduction = (env = NODE_ENV) => (env === 'production' || env === 'prod') ||
+export const isProduction = (env = NODE_ENV) =>
+  env === 'production' ||
+  env === 'prod' ||
   (env !== 'development' && env !== 'dev' && env !== 'test')
 export const isTest = (env = NODE_ENV) => env === 'test'
-export const isDevelopment = (env = NODE_ENV) => env === 'development' || env === 'dev'
+export const isDevelopment = (env = NODE_ENV) =>
+  env === 'development' || env === 'dev'
 
 export const getNev = (key, env = NODE_ENV) => env[key]