@domql/element 2.3.117 → 2.4.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016 symbo.ls
+Copyright (c) 2023 symbo.ls
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/applyParam.js

@@ -0,0 +1,25 @@
+'use strict'
+
+import { isFunction } from '@domql/utils'
+import { registry } from './mixins'
+
+export const applyParam = (param, element, options) => {
+  const { node, context } = element
+  const prop = element[param]
+
+  const DOMQLProperty = registry[param]
+  const DOMQLPropertyFromContext = context && context.registry && context.registry[param]
+  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty
+
+  const hasDefine = element.define && element.define[param]
+  const hasContextDefine = context && context.define && context.define[param]
+
+  if (isGlobalTransformer && !hasContextDefine) {
+    if (isFunction(isGlobalTransformer)) {
+      isGlobalTransformer(prop, element, node, options)
+      return
+    }
+  }
+
+  return { hasDefine, hasContextDefine }
+}

package/create.js

@@ -0,0 +1,314 @@
+'use strict'
+
+import { isObject, isFunction, isString, exec, is, isNode, isUndefined, createKey } from '@domql/utils'
+import { ROOT } from './tree'
+import { TAGS } from '@domql/registry'
+import { triggerEventOn } from '@domql/event'
+import { appendNode, assignNode } from '@domql/render'
+import { assignClass } from '@domql/classlist'
+import { cacheNode, detectTag } from '@domql/node'
+import { createState } from '@domql/state'
+
+import { isMethod } from './methods'
+
+import { createProps } from './props'
+
+import createNode from './node'
+import { applyExtend } from './extend'
+import { registry } from './mixins'
+import { throughInitialExec } from './iterate'
+import OPTIONS from './cache/options'
+
+import {
+  applyComponentFromContext,
+  applyKeyComponentAsExtend,
+  applyVariant,
+  checkIfKeyIsComponent,
+  isVariant
+} from './utils/component'
+import { addMethods } from './methods/set'
+
+const ENV = process.env.NODE_ENV
+
+/**
+ * Creating a domQL element using passed parameters
+ */
+const create = (element, parent, key, options = OPTIONS.create || {}) => {
+  if (options && !OPTIONS.create) {
+    OPTIONS.create = options
+    OPTIONS.create.context = element.context || options.context
+  }
+
+  // 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)
+    }
+    element = {}
+  }
+  if (isString(key) && key.slice(0, 2 === '__')) {
+    if (ENV === 'test' || ENV === 'development') {
+      console.warn(key, 'seems like to be in __ref')
+    }
+  }
+  if (element === null) return
+  if (element === true) element = { text: true }
+
+  // if element is extend
+  if (element.__hash) {
+    element = { extend: element }
+  }
+
+  // if PARENT is not given
+  if (!parent) parent = ROOT
+  if (isNode(parent)) {
+    parent = ROOT[`${key}_parent`] = { key: ':root', node: parent }
+  }
+
+  // if element is STRING
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key)
+  }
+
+  // define KEY
+  const assignedKey = (element.key || key || createKey()).toString()
+
+  if (checkIfKeyIsComponent(assignedKey)) {
+    element = applyKeyComponentAsExtend(element, parent, assignedKey)
+  }
+
+  // TODO: move as define plugins
+  // Responsive rendering
+  if (checkIfMedia(assignedKey)) {
+    element = applyMediaProps(element, parent, assignedKey)
+  }
+
+  if (element.__ref) element.__ref.origin = element
+  else element.__ref = { origin: element } // eslint-disable-line 
+  const __ref = element.__ref
+
+  // assign context
+  applyContext(element, parent, options)
+  const { context } = element
+
+  if (context && context.components) {
+    applyComponentFromContext(element, parent, options)
+  }
+
+  // create EXTEND inheritance
+  applyExtend(element, parent, options)
+
+  // create and assign a KEY
+  element.key = assignedKey
+
+  // Only resolve extends, skip everything else
+  if (options.onlyResolveExtends) {
+    return resolveExtends(element, parent, options)
+  }
+
+  if (Object.keys(options).length) {
+    registry.defaultOptions = options
+    if (options.ignoreChildExtend) delete options.ignoreChildExtend
+  }
+
+  addCaching(element, parent)
+
+  addMethods(element, parent)
+
+  // enable STATE
+  element.state = createState(element, parent)
+
+  // don't render IF in condition
+  checkIf(element, parent)
+
+  // if it already HAS a NODE
+  if (element.node && __ref.__if) { // TODO: check on if
+    return assignNode(element, parent, assignedKey)
+  }
+
+  // apply props settings
+  if (__ref.__if) createProps(element, parent)
+
+  // apply variants
+  applyVariant(element, parent)
+
+  // run `on.init`
+  const initReturns = triggerEventOn('init', element, options)
+  if (initReturns === false) return element
+
+  // run `on.beforeClassAssign`
+  triggerEventOn('beforeClassAssign', element, options)
+
+  // generate a CLASS name
+  assignClass(element)
+
+  renderElement(element, parent, options)
+
+  if (parent.__ref && parent.__ref.__children) parent.__ref.__children.push(element.key)
+
+  triggerEventOn('complete', element, options)
+
+  return element
+}
+
+const renderElement = (element, parent, options) => {
+  const { __ref: ref, key } = element
+
+  // CREATE a real NODE
+  createNode(element, options)
+
+  if (!ref.__if) return element
+
+  // assign NODE
+  assignNode(element, parent, key)
+
+  // run `on.renderRouter`
+  triggerEventOn('renderRouter', element, options)
+
+  // run `on.render`
+  triggerEventOn('render', element, options)
+}
+
+const checkIfPrimitive = (element) => {
+  return is(element)('string', 'number')
+}
+
+const applyValueAsText = (element, parent, key) => {
+  const extendTag = element.extend && element.extend.tag
+  const childExtendTag = parent.childExtend && parent.childExtend.tag
+  const isKeyValidHTMLTag = ((TAGS.body.indexOf(key) > -1) && key)
+  return {
+    text: element,
+    tag: extendTag || childExtendTag || isKeyValidHTMLTag || 'string'
+  }
+}
+
+const applyContext = (element, parent, options) => {
+  if (options.context && !ROOT.context && !element.context) ROOT.context = options.context
+  if (!element.context) element.context = parent.context || options.context || ROOT.context
+}
+
+const checkIf = (element, parent) => {
+  const { __ref: ref } = element
+
+  if (isFunction(element.if)) {
+    // TODO: move as fragment
+    const ifPassed = element.if(element, element.state)
+    if (!ifPassed) {
+      const ifFragment = cacheNode({ tag: 'fragment' })
+      ref.__ifFragment = appendNode(ifFragment, parent.node)
+      delete ref.__if
+    } else ref.__if = true
+  } else ref.__if = true
+}
+
+const addCaching = (element, parent) => {
+  const { __ref: ref } = element
+  let { __ref: parentRef } = parent
+
+  // enable TRANSFORM in data
+  if (!element.transform) element.transform = {}
+
+  // enable CACHING
+  if (!ref.__cached) ref.__cached = {}
+  if (!ref.__defineCache) ref.__defineCache = {}
+
+  // enable EXEC
+  if (!ref.__exec) ref.__exec = {}
+
+  // 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 = []
+
+  // Add _root element property
+  const hasRoot = parent && parent.key === ':root'
+  if (!ref.__root) ref.__root = hasRoot ? element : parentRef.__root
+
+  // set the PATH array
+  if (ENV === 'test' || ENV === 'development') {
+    if (!parentRef) parentRef = parent.ref = {}
+    if (!parentRef.__path) parentRef.__path = []
+    ref.__path = parentRef.__path.concat(element.key)
+  }
+}
+
+const resolveExtends = (element, parent, options) => {
+  const { __ref } = element
+  element.tag = detectTag(element)
+
+  if (!__ref.__exec) __ref.__exec = {}
+  if (!__ref.__attr) __ref.__attr = {}
+
+  if (!element.props) element.props = {}
+  if (!element.state) element.state = {}
+
+  createState(element, parent, { skipApplyMethods: true })
+  createProps(element, parent)
+  applyVariant(element, parent)
+
+  throughInitialExec(element, options.propsExcludedFromExec)
+
+  for (const param in element) {
+    const prop = element[param]
+    if (
+      isUndefined(prop) ||
+      isMethod(param) ||
+      isObject(registry[param]) ||
+      isVariant(param)
+    ) continue
+
+    const hasDefined = element.define && element.define[param]
+    const ourParam = registry[param]
+    const hasOptionsDefine = options.define && options.define[param]
+    if (ourParam && !hasOptionsDefine) continue
+    else if (element[param] && !hasDefined && !hasOptionsDefine) {
+      create(exec(prop, element), element, param, options)
+    }
+  }
+
+  delete element.parent
+  delete element.update
+  delete element.__element
+
+  // added by createProps
+  delete element.props.update
+  delete element.props.__element
+
+  // added by createState
+  delete element.state.__element
+  delete element.state.__element
+  if (!options.keepRef) delete element.__ref
+
+  return element
+}
+
+const checkIfMedia = (key) => key.slice(0, 1) === '@'
+
+const applyMediaProps = (element, parent, key) => {
+  const { props } = element
+  if (props) {
+    props.display = 'none'
+    if (props[key]) props[key].display = props.display
+    else props[key] = { display: props.display || 'block' }
+    return element
+  } else {
+    return {
+      ...element,
+      props: {
+        display: 'none',
+        [key]: { display: 'block' }
+      }
+    }
+  }
+}
+
+export default create

package/define.js

@@ -0,0 +1,13 @@
+'use strict'
+
+import { report } from '@domql/report'
+import { registry } from './mixins'
+
+export default (params, options = {}) => {
+  const { overwrite } = options
+  for (const param in params) {
+    if (registry[param] && !overwrite) {
+      report('OverwriteToBuiltin', param)
+    } else registry[param] = params[param]
+  }
+}

package/dist/cjs/applyParam.js

@@ -0,0 +1,41 @@
+"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);
+var applyParam_exports = {};
+__export(applyParam_exports, {
+  applyParam: () => applyParam
+});
+module.exports = __toCommonJS(applyParam_exports);
+var import_utils = require("@domql/utils");
+var import_mixins = require("./mixins");
+const applyParam = (param, element, options) => {
+  const { node, context } = element;
+  const prop = element[param];
+  const DOMQLProperty = import_mixins.registry[param];
+  const DOMQLPropertyFromContext = context && context.registry && context.registry[param];
+  const isGlobalTransformer = DOMQLPropertyFromContext || DOMQLProperty;
+  const hasDefine = element.define && element.define[param];
+  const hasContextDefine = context && context.define && context.define[param];
+  if (isGlobalTransformer && !hasContextDefine) {
+    if ((0, import_utils.isFunction)(isGlobalTransformer)) {
+      isGlobalTransformer(prop, element, node, options);
+      return;
+    }
+  }
+  return { hasDefine, hasContextDefine };
+};

package/dist/cjs/create.js

@@ -0,0 +1,262 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var create_exports = {};
+__export(create_exports, {
+  default: () => create_default
+});
+module.exports = __toCommonJS(create_exports);
+var import_utils = require("@domql/utils");
+var import_tree = require("./tree");
+var import_registry = require("@domql/registry");
+var import_event = require("@domql/event");
+var import_render = require("@domql/render");
+var import_classlist = require("@domql/classlist");
+var import_node = require("@domql/node");
+var import_state = require("@domql/state");
+var import_methods = require("./methods");
+var import_props = require("./props");
+var import_node2 = __toESM(require("./node"), 1);
+var import_extend = require("./extend");
+var import_mixins = require("./mixins");
+var import_iterate = require("./iterate");
+var import_options = __toESM(require("./cache/options"), 1);
+var import_component = require("./utils/component");
+var import_set = require("./methods/set");
+const ENV = "development";
+const create = (element, parent, key, options = import_options.default.create || {}) => {
+  if (options && !import_options.default.create) {
+    import_options.default.create = options;
+    import_options.default.create.context = element.context || options.context;
+  }
+  if (element === void 0) {
+    if (ENV === "test" || ENV === "development") {
+      console.warn(key, "element is undefined in", parent && parent.__ref && parent.__ref.path);
+    }
+    element = {};
+  }
+  if ((0, import_utils.isString)(key) && key.slice(0, 2 === "__")) {
+    if (ENV === "test" || ENV === "development") {
+      console.warn(key, "seems like to be in __ref");
+    }
+  }
+  if (element === null)
+    return;
+  if (element === true)
+    element = { text: true };
+  if (element.__hash) {
+    element = { extend: element };
+  }
+  if (!parent)
+    parent = import_tree.ROOT;
+  if ((0, import_utils.isNode)(parent)) {
+    parent = import_tree.ROOT[`${key}_parent`] = { key: ":root", node: parent };
+  }
+  if (checkIfPrimitive(element)) {
+    element = applyValueAsText(element, parent, key);
+  }
+  const assignedKey = (element.key || key || (0, import_utils.createKey)()).toString();
+  if ((0, import_component.checkIfKeyIsComponent)(assignedKey)) {
+    element = (0, import_component.applyKeyComponentAsExtend)(element, parent, assignedKey);
+  }
+  if (checkIfMedia(assignedKey)) {
+    element = applyMediaProps(element, parent, assignedKey);
+  }
+  if (element.__ref)
+    element.__ref.origin = element;
+  else
+    element.__ref = { origin: element };
+  const __ref = element.__ref;
+  applyContext(element, parent, options);
+  const { context } = element;
+  if (context && context.components) {
+    (0, import_component.applyComponentFromContext)(element, parent, options);
+  }
+  (0, import_extend.applyExtend)(element, parent, options);
+  element.key = assignedKey;
+  if (options.onlyResolveExtends) {
+    return resolveExtends(element, parent, options);
+  }
+  if (Object.keys(options).length) {
+    import_mixins.registry.defaultOptions = options;
+    if (options.ignoreChildExtend)
+      delete options.ignoreChildExtend;
+  }
+  addCaching(element, parent);
+  (0, import_set.addMethods)(element, parent);
+  element.state = (0, import_state.createState)(element, parent);
+  checkIf(element, parent);
+  if (element.node && __ref.__if) {
+    return (0, import_render.assignNode)(element, parent, assignedKey);
+  }
+  if (__ref.__if)
+    (0, import_props.createProps)(element, parent);
+  (0, import_component.applyVariant)(element, parent);
+  const initReturns = (0, import_event.triggerEventOn)("init", element, options);
+  if (initReturns === false)
+    return element;
+  (0, import_event.triggerEventOn)("beforeClassAssign", element, options);
+  (0, import_classlist.assignClass)(element);
+  renderElement(element, parent, options);
+  if (parent.__ref && parent.__ref.__children)
+    parent.__ref.__children.push(element.key);
+  (0, import_event.triggerEventOn)("complete", element, options);
+  return element;
+};
+const renderElement = (element, parent, options) => {
+  const { __ref: ref, key } = element;
+  (0, import_node2.default)(element, options);
+  if (!ref.__if)
+    return element;
+  (0, import_render.assignNode)(element, parent, key);
+  (0, import_event.triggerEventOn)("renderRouter", element, options);
+  (0, import_event.triggerEventOn)("render", element, options);
+};
+const checkIfPrimitive = (element) => {
+  return (0, import_utils.is)(element)("string", "number");
+};
+const applyValueAsText = (element, parent, key) => {
+  const extendTag = element.extend && element.extend.tag;
+  const childExtendTag = parent.childExtend && parent.childExtend.tag;
+  const isKeyValidHTMLTag = import_registry.TAGS.body.indexOf(key) > -1 && key;
+  return {
+    text: element,
+    tag: extendTag || childExtendTag || isKeyValidHTMLTag || "string"
+  };
+};
+const applyContext = (element, parent, options) => {
+  if (options.context && !import_tree.ROOT.context && !element.context)
+    import_tree.ROOT.context = options.context;
+  if (!element.context)
+    element.context = parent.context || options.context || import_tree.ROOT.context;
+};
+const checkIf = (element, parent) => {
+  const { __ref: ref } = element;
+  if ((0, import_utils.isFunction)(element.if)) {
+    const ifPassed = element.if(element, element.state);
+    if (!ifPassed) {
+      const ifFragment = (0, import_node.cacheNode)({ tag: "fragment" });
+      ref.__ifFragment = (0, import_render.appendNode)(ifFragment, parent.node);
+      delete ref.__if;
+    } else
+      ref.__if = true;
+  } else
+    ref.__if = true;
+};
+const addCaching = (element, parent) => {
+  const { __ref: ref } = element;
+  let { __ref: parentRef } = parent;
+  if (!element.transform)
+    element.transform = {};
+  if (!ref.__cached)
+    ref.__cached = {};
+  if (!ref.__defineCache)
+    ref.__defineCache = {};
+  if (!ref.__exec)
+    ref.__exec = {};
+  if (!ref.__class)
+    ref.__class = {};
+  if (!ref.__classNames)
+    ref.__classNames = {};
+  if (!ref.__attr)
+    ref.__attr = {};
+  if (!ref.__changes)
+    ref.__changes = [];
+  if (!ref.__children)
+    ref.__children = [];
+  const hasRoot = parent && parent.key === ":root";
+  if (!ref.__root)
+    ref.__root = hasRoot ? element : parentRef.__root;
+  if (ENV === "test" || ENV === "development") {
+    if (!parentRef)
+      parentRef = parent.ref = {};
+    if (!parentRef.__path)
+      parentRef.__path = [];
+    ref.__path = parentRef.__path.concat(element.key);
+  }
+};
+const resolveExtends = (element, parent, options) => {
+  const { __ref } = element;
+  element.tag = (0, import_node.detectTag)(element);
+  if (!__ref.__exec)
+    __ref.__exec = {};
+  if (!__ref.__attr)
+    __ref.__attr = {};
+  if (!element.props)
+    element.props = {};
+  if (!element.state)
+    element.state = {};
+  (0, import_state.createState)(element, parent, { skipApplyMethods: true });
+  (0, import_props.createProps)(element, parent);
+  (0, import_component.applyVariant)(element, parent);
+  (0, import_iterate.throughInitialExec)(element, options.propsExcludedFromExec);
+  for (const param in element) {
+    const prop = element[param];
+    if ((0, import_utils.isUndefined)(prop) || (0, import_methods.isMethod)(param) || (0, import_utils.isObject)(import_mixins.registry[param]) || (0, import_component.isVariant)(param))
+      continue;
+    const hasDefined = element.define && element.define[param];
+    const ourParam = import_mixins.registry[param];
+    const hasOptionsDefine = options.define && options.define[param];
+    if (ourParam && !hasOptionsDefine)
+      continue;
+    else if (element[param] && !hasDefined && !hasOptionsDefine) {
+      create((0, import_utils.exec)(prop, element), element, param, options);
+    }
+  }
+  delete element.parent;
+  delete element.update;
+  delete element.__element;
+  delete element.props.update;
+  delete element.props.__element;
+  delete element.state.__element;
+  delete element.state.__element;
+  if (!options.keepRef)
+    delete element.__ref;
+  return element;
+};
+const checkIfMedia = (key) => key.slice(0, 1) === "@";
+const applyMediaProps = (element, parent, key) => {
+  const { props } = element;
+  if (props) {
+    props.display = "none";
+    if (props[key])
+      props[key].display = props.display;
+    else
+      props[key] = { display: props.display || "block" };
+    return element;
+  } else {
+    return {
+      ...element,
+      props: {
+        display: "none",
+        [key]: { display: "block" }
+      }
+    };
+  }
+};
+var create_default = create;

package/dist/cjs/define.js

@@ -0,0 +1,34 @@
+"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);
+var define_exports = {};
+__export(define_exports, {
+  default: () => define_default
+});
+module.exports = __toCommonJS(define_exports);
+var import_report = require("@domql/report");
+var import_mixins = require("./mixins");
+var define_default = (params, options = {}) => {
+  const { overwrite } = options;
+  for (const param in params) {
+    if (import_mixins.registry[param] && !overwrite) {
+      (0, import_report.report)("OverwriteToBuiltin", param);
+    } else
+      import_mixins.registry[param] = params[param];
+  }
+};