@domql/qsql 0.1.0 → 3.3.0

package/dist/iife/index.js

@@ -0,0 +1,205 @@
+var DomqlQsql = (() => {
+  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);
+
+  // index.js
+  var index_exports = {};
+  __export(index_exports, {
+    REGISTRY: () => REGISTRY,
+    default: () => index_default,
+    define: () => define,
+    find: () => find,
+    methods: () => methods,
+    query: () => query,
+    setMethod: () => setMethod
+  });
+
+  // registry.js
+  var REGISTRY = {};
+
+  // params.js
+  var isObject = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+  var applyStyle = (params2, element, node) => {
+    if (params2 && isObject(params2)) {
+      for (const prop in params2) {
+        node.style[prop] = params2[prop];
+      }
+    }
+  };
+  var 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);
+        }
+      }
+    }
+  };
+  var 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();
+    }
+  };
+  var applyData = (params2, element, node) => {
+    if (params2 && isObject(params2)) {
+      for (const key in params2) {
+        node.dataset[key] = params2[key];
+      }
+    }
+  };
+  var applyText = (param, element, node) => {
+    node.textContent = param;
+  };
+  var applyHtml = (param, element, node) => {
+    node.innerHTML = param;
+  };
+  var params = {
+    attr: applyAttr,
+    class: applyClassList,
+    data: applyData,
+    style: applyStyle,
+    text: applyText,
+    html: applyHtml
+  };
+
+  // on.js
+  var isFunction = (v) => typeof v === "function";
+  var 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);
+      }
+    }
+  };
+
+  // apply.js
+  var isObject2 = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+  var isFunction2 = (v) => typeof v === "function";
+  var apply = (element) => {
+    element.nodes.forEach((node) => {
+      if (isObject2(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 && isFunction2(element.on.init)) {
+        element.on.init.call(element, element, node);
+      }
+    });
+  };
+
+  // update.js
+  var isObject3 = (v) => v !== null && typeof v === "object" && v.constructor === Object;
+  var isFunction3 = (v) => typeof v === "function";
+  var update = function(newParams) {
+    const element = this;
+    element.nodes.forEach((node) => {
+      if (isObject3(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 && isFunction3(element.on.update)) {
+      element.on.update.call(element, element);
+    }
+  };
+
+  // methods.js
+  var methods = {};
+  var setMethod = (newMethods) => {
+    for (const param in newMethods) {
+      methods[param] = newMethods[param];
+    }
+    return methods;
+  };
+
+  // query.js
+  var isNode = (obj) => obj instanceof Node;
+  var 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;
+  };
+
+  // define.js
+  var 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];
+      }
+    }
+  };
+
+  // find.js
+  var find = (key) => {
+    const element = REGISTRY[key];
+    if (!element) console.warn(`Can't find element "${key}"`);
+    return element;
+  };
+
+  // index.js
+  var index_default = {
+    REGISTRY,
+    query,
+    define,
+    find,
+    methods,
+    setMethod
+  };
+  return __toCommonJS(index_exports);
+})();

package/find.js

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

package/index.js

@@ -0,0 +1,23 @@
+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'
+
+export {
+  REGISTRY,
+  query,
+  define,
+  find,
+  methods,
+  setMethod
+}
+
+export default {
+  REGISTRY,
+  query,
+  define,
+  find,
+  methods,
+  setMethod
+}

package/{src/methods.js → methods.js}

@@ -1,8 +1,6 @@
-'use strict'
-
 export const methods = {}
 
-export const setMethod = newMethods => {
+export const setMethod = (newMethods) => {
   for (const param in newMethods) {
     methods[param] = newMethods[param]
   }

package/on.js

@@ -0,0 +1,14 @@
+const isFunction = (v) => typeof v === 'function'
+
+export 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/package.json

@@ -1,11 +1,37 @@
 {
   "name": "@domql/qsql",
-  "version": "0.1.0",
-  "main": "src/index.js",
-  "author": "symbo.ls",
+  "version": "3.3.0",
   "license": "MIT",
-  "private": false,
-  "dependencies": {
-    "domql": "latest"
-  }
+  "type": "module",
+  "module": "./dist/esm/index.js",
+  "unpkg": "./dist/iife/index.js",
+  "jsdelivr": "./dist/iife/index.js",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/index.js",
+      "require": "./dist/cjs/index.js",
+      "browser": "./dist/iife/index.js",
+      "default": "./dist/esm/index.js"
+    }
+  },
+  "source": "index.js",
+  "files": [
+    "dist",
+    "*.js"
+  ],
+  "scripts": {
+    "copy:package:cjs": "cp ../../build/package-cjs.json dist/cjs/package.json",
+    "build:esm": "cross-env NODE_ENV=$NODE_ENV esbuild *.js --target=es2020 --format=esm --outdir=dist/esm --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build:cjs": "cross-env NODE_ENV=$NODE_ENV esbuild *.js --target=node18 --format=cjs --outdir=dist/cjs --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build:iife": "cross-env NODE_ENV=$NODE_ENV esbuild index.js --bundle --target=es2020 --format=iife --global-name=DomqlQsql --outfile=dist/iife/index.js --define:process.env.NODE_ENV=process.env.NODE_ENV",
+    "build": "node ../../build/build.js",
+    "prepublish": "npm run build && npm run copy:package:cjs"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "@babel/core": "^7.26.0"
+  },
+  "browser": "./dist/iife/index.js",
+  "sideEffects": false
 }

package/params.js

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

package/query.js

@@ -0,0 +1,35 @@
+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
+
+export 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
+}

package/registry.js

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

package/update.js

@@ -0,0 +1,22 @@
+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 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)
+  }
+}

package/README.md

@@ -1,45 +0,0 @@
-# qsql
-DOM manipulation using document queries. Uses [DOMQL](https://github.com/domql/domql) API.
-
-### Installation
-```
-yarn add classql
-```
-
-### Examples
-
-Initialization: 
-
-```javascript
-import DOM from 'qsql'
-
-DOM.query({
-  logo: { query: '.logo' }
-})
-```
-
-Attributes:
-```javascript
-DOM.query({
-  modal: {
-    query: '.modal',
-    style: { display: 'none' }
-  }
-})
-```
-
-Events and update:
-```javascript
-DOM.query({
-  CTA: {
-    query: '.button',
-    on: {
-      click: (event, element, node) => {
-        DOM.find('modal').update({
-          style: { display: 'block' }
-        })
-      }
-    }
-  }
-})
-```

package/src/apply.js

@@ -1,22 +0,0 @@
-'use strict'
-
-import { init } from '@rackai/domql/src/event/on'
-import { exec, isObject } from '@rackai/domql/src/utils/object'
-
-import params from './params'
-import on from './on'
-
-export default element => {
-  element.nodes.forEach(node => {
-    if (isObject(element.on)) on(element, node)
-
-    for (let key in element) {
-      var elemParam = element[key]
-      var param = params[key]
-      if (param) param(elemParam, element, node)
-    }
-
-    if (element.on && typeof element.on.init === 'function')
-      init(element.on.init, element, node)
-  })
-}

package/src/define.js

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

package/src/find.js

@@ -1,5 +0,0 @@
-'use strict'
-
-import registry from './registry'
-
-export default query => registry[query] || console.warn(`Can't find element "${query}"`)

package/src/index.js

@@ -1,18 +0,0 @@
-'use strict'
-
-import '@rackai/domql'
-
-import query from './query'
-import registry from './registry'
-import define from './define'
-import find from './find'
-import { methods, setMethod } from './methods'
-
-export default {
-  registry,
-  query,
-  define,
-  find,
-  methods,
-  setMethod
-}

package/src/on.js

@@ -1,18 +0,0 @@
-'use strict'
-
-import * as events from '@rackai/domql/src/event/on'
-
-events.init = (param, element, node) => {
-  param.call(element, element, node)
-}
-
-export default (element, node) => {
-  for (const param in element.on) {
-    if (param === 'init' || param === 'render') continue
-
-    var appliedFunction = element.on[param]
-    if (typeof appliedFunction === 'function') {
-      node.addEventListener(param, event => appliedFunction(event, element), true)
-    }
-  }
-}

package/src/params.js

@@ -1,20 +0,0 @@
-'use strict'
-
-import {
-  attr,
-  classList,
-  data,
-  style,
-  html
-} from '@rackai/domql/src/element/params'
-
-export default {
-  attr,
-  class: classList,
-  data,
-  style,
-  text: (param, element, node) => {
-    node.innerText = param
-  },
-  html
-}

package/src/query.js

@@ -1,37 +0,0 @@
-'use strict'
-
-import registry from './registry'
-import apply from './apply'
-import update from './update'
-import { methods } from './methods'
-import { is } from '@rackai/domql/src/event'
-
-var query = params => {
-  for (let key in params) {
-    var element = params[key]
-    var { query, node } = element
-    var nodesArr = []
-
-    if (is.node(node)) nodesArr = [node]
-    else {
-      var nodes = document.querySelectorAll(query)
-      var { length } = nodes
-      if (length === 0) console.warn(`Could not find element "${key}"`)
-      nodes.forEach((node, key) => nodesArr[key] = node)
-    }
-
-    element.nodes = nodesArr
-    element.key = key
-    element.update = update
-
-    for (var one in methods) if (key !== one) element[one] = methods[one]
-    
-    registry[key] = params[key]
-
-    apply(element)
-  }
-
-  return registry
-}
-
-export default query

package/src/registry.js

@@ -1,3 +0,0 @@
-'use strict'
-
-export default {}

package/src/update.js

@@ -1,24 +0,0 @@
-'use strict'
-
-import params from './params'
-import on from './on'
-import { exec, isObject } from '@rackai/domql/src/utils/object'
-
-const update = function (newParams) {
-  var element = this
-  element.nodes.forEach(node => {
-    if (isObject(newParams.on)) on(element, node)
-    for (let param in newParams) {
-      var newParam = newParams[param]
-      var hasParam = params[param]
-      if (hasParam) hasParam(newParam, element, node)
-    }
-  })
-
-  // run onUpdate
-  if (element.on && typeof element.on.update === 'function') {
-    on.update(element.on.update, element, node)
-  }
-}
-
-export default update