@domql/qsql 0.1.0 → 3.2.7

package/apply.js

@@ -0,0 +1,21 @@
+import { params } from './params.js'
+import { applyEvents } from './on.js'
+
+const isObject = (v) => v !== null && typeof v === 'object' && v.constructor === Object
+const isFunction = (v) => typeof v === 'function'
+
+export const apply = (element) => {
+  element.nodes.forEach(node => {
+    if (isObject(element.on)) applyEvents(element, node)
+
+    for (const key in element) {
+      const elemParam = element[key]
+      const param = params[key]
+      if (param) param(elemParam, element, node)
+    }
+
+    if (element.on && isFunction(element.on.init)) {
+      element.on.init.call(element, element, node)
+    }
+  })
+}

package/define.js

@@ -0,0 +1,12 @@
+import { params } from './params.js'
+
+export const define = (newParams, options = {}) => {
+  const { overwrite } = options
+  for (const param in newParams) {
+    if (params[param] && !overwrite) {
+      console.warn('Can\'t overwrite default params. Use { overwrite: true } to force update')
+    } else {
+      params[param] = newParams[param]
+    }
+  }
+}

package/dist/cjs/apply.js

@@ -0,0 +1,39 @@
+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 apply_exports = {};
+__export(apply_exports, {
+  apply: () => apply
+});
+module.exports = __toCommonJS(apply_exports);
+var import_params = require("./params.js");
+var import_on = require("./on.js");
+const isObject = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+const isFunction = (v) => typeof v === "function";
+const apply = (element) => {
+  element.nodes.forEach((node) => {
+    if (isObject(element.on)) (0, import_on.applyEvents)(element, node);
+    for (const key in element) {
+      const elemParam = element[key];
+      const param = import_params.params[key];
+      if (param) param(elemParam, element, node);
+    }
+    if (element.on && isFunction(element.on.init)) {
+      element.on.init.call(element, element, node);
+    }
+  });
+};

package/dist/cjs/define.js

@@ -0,0 +1,33 @@
+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, {
+  define: () => define
+});
+module.exports = __toCommonJS(define_exports);
+var import_params = require("./params.js");
+const define = (newParams, options = {}) => {
+  const { overwrite } = options;
+  for (const param in newParams) {
+    if (import_params.params[param] && !overwrite) {
+      console.warn("Can't overwrite default params. Use { overwrite: true } to force update");
+    } else {
+      import_params.params[param] = newParams[param];
+    }
+  }
+};

package/dist/cjs/find.js

@@ -0,0 +1,28 @@
+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 find_exports = {};
+__export(find_exports, {
+  find: () => find
+});
+module.exports = __toCommonJS(find_exports);
+var import_registry = require("./registry.js");
+const find = (key) => {
+  const element = import_registry.REGISTRY[key];
+  if (!element) console.warn(`Can't find element "${key}"`);
+  return element;
+};

package/dist/cjs/index.js

@@ -0,0 +1,41 @@
+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 index_exports = {};
+__export(index_exports, {
+  REGISTRY: () => import_registry.REGISTRY,
+  default: () => index_default,
+  define: () => import_define.define,
+  find: () => import_find.find,
+  methods: () => import_methods.methods,
+  query: () => import_query.query,
+  setMethod: () => import_methods.setMethod
+});
+module.exports = __toCommonJS(index_exports);
+var import_registry = require("./registry.js");
+var import_query = require("./query.js");
+var import_define = require("./define.js");
+var import_find = require("./find.js");
+var import_methods = require("./methods.js");
+var index_default = {
+  REGISTRY: import_registry.REGISTRY,
+  query: import_query.query,
+  define: import_define.define,
+  find: import_find.find,
+  methods: import_methods.methods,
+  setMethod: import_methods.setMethod
+};

package/dist/cjs/methods.js

@@ -0,0 +1,30 @@
+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 methods_exports = {};
+__export(methods_exports, {
+  methods: () => methods,
+  setMethod: () => setMethod
+});
+module.exports = __toCommonJS(methods_exports);
+const methods = {};
+const setMethod = (newMethods) => {
+  for (const param in newMethods) {
+    methods[param] = newMethods[param];
+  }
+  return methods;
+};

package/dist/cjs/on.js

@@ -0,0 +1,34 @@
+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 on_exports = {};
+__export(on_exports, {
+  applyEvents: () => applyEvents
+});
+module.exports = __toCommonJS(on_exports);
+const isFunction = (v) => typeof v === "function";
+const applyEvents = (element, node) => {
+  for (const param in element.on) {
+    if (param === "init" || param === "render") continue;
+    const appliedFunction = element.on[param];
+    if (isFunction(appliedFunction)) {
+      node.addEventListener(param, (event) => {
+        appliedFunction.call(element, event, element, node);
+      }, true);
+    }
+  }
+};

package/dist/cjs/params.js

@@ -0,0 +1,77 @@
+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 params_exports = {};
+__export(params_exports, {
+  params: () => params
+});
+module.exports = __toCommonJS(params_exports);
+const isObject = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+const applyStyle = (params2, element, node) => {
+  if (params2 && isObject(params2)) {
+    for (const prop in params2) {
+      node.style[prop] = params2[prop];
+    }
+  }
+};
+const applyAttr = (params2, element, node) => {
+  if (params2 && isObject(params2)) {
+    for (const attr in params2) {
+      const val = params2[attr];
+      if (val !== false && val !== void 0 && val !== null) {
+        node.setAttribute(attr, val);
+      } else {
+        node.removeAttribute(attr);
+      }
+    }
+  }
+};
+const applyClassList = (params2, element, node) => {
+  if (!params2) return;
+  if (typeof params2 === "string") {
+    node.className = params2;
+  } else if (isObject(params2)) {
+    let className = "";
+    for (const item in params2) {
+      const val = params2[item];
+      if (val === true) className += ` ${item}`;
+      else if (typeof val === "string") className += ` ${val}`;
+    }
+    node.className = className.trim();
+  }
+};
+const applyData = (params2, element, node) => {
+  if (params2 && isObject(params2)) {
+    for (const key in params2) {
+      node.dataset[key] = params2[key];
+    }
+  }
+};
+const applyText = (param, element, node) => {
+  node.textContent = param;
+};
+const applyHtml = (param, element, node) => {
+  node.innerHTML = param;
+};
+const params = {
+  attr: applyAttr,
+  class: applyClassList,
+  data: applyData,
+  style: applyStyle,
+  text: applyText,
+  html: applyHtml
+};

package/dist/cjs/query.js

@@ -0,0 +1,50 @@
+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 query_exports = {};
+__export(query_exports, {
+  query: () => query
+});
+module.exports = __toCommonJS(query_exports);
+var import_registry = require("./registry.js");
+var import_apply = require("./apply.js");
+var import_update = require("./update.js");
+var import_methods = require("./methods.js");
+const isNode = (obj) => obj instanceof Node;
+const query = (config) => {
+  for (const key in config) {
+    const element = config[key];
+    const { query: selector, node } = element;
+    const nodesArr = [];
+    if (node && isNode(node)) {
+      nodesArr.push(node);
+    } else if (selector) {
+      const nodes = document.querySelectorAll(selector);
+      if (nodes.length === 0) console.warn(`Could not find element "${key}"`);
+      nodes.forEach((n) => nodesArr.push(n));
+    }
+    element.nodes = nodesArr;
+    element.key = key;
+    element.update = import_update.update;
+    for (const name in import_methods.methods) {
+      if (key !== name) element[name] = import_methods.methods[name];
+    }
+    import_registry.REGISTRY[key] = element;
+    (0, import_apply.apply)(element);
+  }
+  return import_registry.REGISTRY;
+};

package/dist/cjs/registry.js

@@ -0,0 +1,23 @@
+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 registry_exports = {};
+__export(registry_exports, {
+  REGISTRY: () => REGISTRY
+});
+module.exports = __toCommonJS(registry_exports);
+const REGISTRY = {};

package/dist/cjs/update.js

@@ -0,0 +1,40 @@
+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 update_exports = {};
+__export(update_exports, {
+  update: () => update
+});
+module.exports = __toCommonJS(update_exports);
+var import_params = require("./params.js");
+var import_on = require("./on.js");
+const isObject = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+const isFunction = (v) => typeof v === "function";
+const update = function(newParams) {
+  const element = this;
+  element.nodes.forEach((node) => {
+    if (isObject(newParams.on)) (0, import_on.applyEvents)(element, node);
+    for (const param in newParams) {
+      const newParam = newParams[param];
+      const hasParam = import_params.params[param];
+      if (hasParam) hasParam(newParam, element, node);
+    }
+  });
+  if (element.on && isFunction(element.on.update)) {
+    element.on.update.call(element, element);
+  }
+};

package/dist/esm/apply.js

@@ -0,0 +1,20 @@
+import { params } from "./params.js";
+import { applyEvents } from "./on.js";
+const isObject = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+const isFunction = (v) => typeof v === "function";
+const apply = (element) => {
+  element.nodes.forEach((node) => {
+    if (isObject(element.on)) applyEvents(element, node);
+    for (const key in element) {
+      const elemParam = element[key];
+      const param = params[key];
+      if (param) param(elemParam, element, node);
+    }
+    if (element.on && isFunction(element.on.init)) {
+      element.on.init.call(element, element, node);
+    }
+  });
+};
+export {
+  apply
+};

package/dist/esm/define.js

@@ -0,0 +1,14 @@
+import { params } from "./params.js";
+const define = (newParams, options = {}) => {
+  const { overwrite } = options;
+  for (const param in newParams) {
+    if (params[param] && !overwrite) {
+      console.warn("Can't overwrite default params. Use { overwrite: true } to force update");
+    } else {
+      params[param] = newParams[param];
+    }
+  }
+};
+export {
+  define
+};

package/dist/esm/find.js

@@ -0,0 +1,9 @@
+import { REGISTRY } from "./registry.js";
+const find = (key) => {
+  const element = REGISTRY[key];
+  if (!element) console.warn(`Can't find element "${key}"`);
+  return element;
+};
+export {
+  find
+};

package/dist/esm/index.js

@@ -0,0 +1,22 @@
+import { REGISTRY } from "./registry.js";
+import { query } from "./query.js";
+import { define } from "./define.js";
+import { find } from "./find.js";
+import { methods, setMethod } from "./methods.js";
+var index_default = {
+  REGISTRY,
+  query,
+  define,
+  find,
+  methods,
+  setMethod
+};
+export {
+  REGISTRY,
+  index_default as default,
+  define,
+  find,
+  methods,
+  query,
+  setMethod
+};

package/dist/esm/methods.js

@@ -0,0 +1,11 @@
+const methods = {};
+const setMethod = (newMethods) => {
+  for (const param in newMethods) {
+    methods[param] = newMethods[param];
+  }
+  return methods;
+};
+export {
+  methods,
+  setMethod
+};

package/dist/esm/on.js

@@ -0,0 +1,15 @@
+const isFunction = (v) => typeof v === "function";
+const applyEvents = (element, node) => {
+  for (const param in element.on) {
+    if (param === "init" || param === "render") continue;
+    const appliedFunction = element.on[param];
+    if (isFunction(appliedFunction)) {
+      node.addEventListener(param, (event) => {
+        appliedFunction.call(element, event, element, node);
+      }, true);
+    }
+  }
+};
+export {
+  applyEvents
+};

package/dist/esm/params.js

@@ -0,0 +1,58 @@
+const isObject = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+const applyStyle = (params2, element, node) => {
+  if (params2 && isObject(params2)) {
+    for (const prop in params2) {
+      node.style[prop] = params2[prop];
+    }
+  }
+};
+const applyAttr = (params2, element, node) => {
+  if (params2 && isObject(params2)) {
+    for (const attr in params2) {
+      const val = params2[attr];
+      if (val !== false && val !== void 0 && val !== null) {
+        node.setAttribute(attr, val);
+      } else {
+        node.removeAttribute(attr);
+      }
+    }
+  }
+};
+const applyClassList = (params2, element, node) => {
+  if (!params2) return;
+  if (typeof params2 === "string") {
+    node.className = params2;
+  } else if (isObject(params2)) {
+    let className = "";
+    for (const item in params2) {
+      const val = params2[item];
+      if (val === true) className += ` ${item}`;
+      else if (typeof val === "string") className += ` ${val}`;
+    }
+    node.className = className.trim();
+  }
+};
+const applyData = (params2, element, node) => {
+  if (params2 && isObject(params2)) {
+    for (const key in params2) {
+      node.dataset[key] = params2[key];
+    }
+  }
+};
+const applyText = (param, element, node) => {
+  node.textContent = param;
+};
+const applyHtml = (param, element, node) => {
+  node.innerHTML = param;
+};
+const params = {
+  attr: applyAttr,
+  class: applyClassList,
+  data: applyData,
+  style: applyStyle,
+  text: applyText,
+  html: applyHtml
+};
+export {
+  params
+};

package/dist/esm/query.js

@@ -0,0 +1,31 @@
+import { REGISTRY } from "./registry.js";
+import { apply } from "./apply.js";
+import { update } from "./update.js";
+import { methods } from "./methods.js";
+const isNode = (obj) => obj instanceof Node;
+const query = (config) => {
+  for (const key in config) {
+    const element = config[key];
+    const { query: selector, node } = element;
+    const nodesArr = [];
+    if (node && isNode(node)) {
+      nodesArr.push(node);
+    } else if (selector) {
+      const nodes = document.querySelectorAll(selector);
+      if (nodes.length === 0) console.warn(`Could not find element "${key}"`);
+      nodes.forEach((n) => nodesArr.push(n));
+    }
+    element.nodes = nodesArr;
+    element.key = key;
+    element.update = update;
+    for (const name in methods) {
+      if (key !== name) element[name] = methods[name];
+    }
+    REGISTRY[key] = element;
+    apply(element);
+  }
+  return REGISTRY;
+};
+export {
+  query
+};

package/dist/esm/registry.js

@@ -0,0 +1,4 @@
+const REGISTRY = {};
+export {
+  REGISTRY
+};

package/dist/esm/update.js

@@ -0,0 +1,21 @@
+import { params } from "./params.js";
+import { applyEvents } from "./on.js";
+const isObject = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+const isFunction = (v) => typeof v === "function";
+const update = function(newParams) {
+  const element = this;
+  element.nodes.forEach((node) => {
+    if (isObject(newParams.on)) applyEvents(element, node);
+    for (const param in newParams) {
+      const newParam = newParams[param];
+      const hasParam = params[param];
+      if (hasParam) hasParam(newParam, element, node);
+    }
+  });
+  if (element.on && isFunction(element.on.update)) {
+    element.on.update.call(element, element);
+  }
+};
+export {
+  update
+};