@oscarpalmer/abydon 0.7.0 → 0.8.0

package/dist/fragment.mjs

@@ -0,0 +1,39 @@
+// src/fragment.ts
+import {createTemplate, getNodes} from "./helpers/dom";
+import {parse} from "./html";
+import {mapNodes} from "./node";
+
+class Fragment {
+  data;
+  constructor(strings, expressions) {
+    this.data = {
+      expressions,
+      strings,
+      nodes: [],
+      values: []
+    };
+  }
+  appendTo(element) {
+    element.append(...this.get());
+  }
+  get() {
+    if (this.data.nodes.length === 0) {
+      const parsed = parse(this.data);
+      const templated = createTemplate(parsed);
+      this.data.nodes.splice(0, this.data.nodes.length, ...getNodes(templated));
+      mapNodes(this.data, this.data.nodes);
+    }
+    return [...this.data.nodes];
+  }
+  remove() {
+    const { length } = this.data.nodes;
+    for (let index = 0;index < length; index += 1) {
+      const node2 = this.data.nodes[index];
+      node2.parentNode?.removeChild(node2);
+    }
+    this.data.nodes.splice(0, length);
+  }
+}
+export {
+  Fragment
+};

package/dist/helpers/dom.mjs

@@ -0,0 +1,46 @@
+// src/helpers/dom.ts
+import {getString} from "@oscarpalmer/atoms/string";
+import {isFragment, isFragmentNode} from "./index";
+function createNodes(value) {
+  if (isFragmentNode(value)) {
+    return [value];
+  }
+  if (isFragment(value)) {
+    return value.get();
+  }
+  return [new Text(getString(value))];
+}
+function createTemplate(html) {
+  const template = document.createElement("template");
+  template.innerHTML = html;
+  const cloned = template.content.cloneNode(true);
+  const scripts = [
+    ...cloned instanceof Element ? cloned.querySelectorAll("script") : []
+  ];
+  const { length } = scripts;
+  for (let index = 0;index < length; index += 1) {
+    scripts[index].remove();
+  }
+  cloned.normalize();
+  return cloned;
+}
+function getNodes(node) {
+  return /^documentfragment$/i.test(node.constructor.name) ? [...node.childNodes] : [node];
+}
+function replaceNodes(from, to) {
+  const { length } = from;
+  for (let index = 0;index < length; index += 1) {
+    const node = from[index];
+    if (index === 0) {
+      node.replaceWith(...to);
+    } else {
+      node.remove();
+    }
+  }
+}
+export {
+  replaceNodes,
+  getNodes,
+  createTemplate,
+  createNodes
+};

package/dist/helpers/index.mjs

@@ -0,0 +1,15 @@
+// src/helpers/index.ts
+function isFragment(value) {
+  return typeof value === "object" && value != null && "$fragment" in value && value.$fragment === true;
+}
+function isFragmentElement(value) {
+  return value instanceof HTMLElement || value instanceof SVGElement;
+}
+function isFragmentNode(value) {
+  return value instanceof Comment || value instanceof Element || value instanceof Text;
+}
+export {
+  isFragmentNode,
+  isFragmentElement,
+  isFragment
+};

package/dist/html.mjs

@@ -0,0 +1,36 @@
+// src/html.ts
+import {isNullableOrWhitespace} from "@oscarpalmer/atoms/is";
+import {Fragment} from "./fragment";
+function handleExpression(data, prefix, expression) {
+  if (isNullableOrWhitespace(expression)) {
+    return prefix;
+  }
+  if (Array.isArray(expression)) {
+    const { length } = expression;
+    let expressions = "";
+    for (let index = 0;index < length; index += 1) {
+      expressions += handleExpression(data, "", expression[index]);
+    }
+    return `${prefix}${expressions}`;
+  }
+  if (typeof expression === "function" || typeof expression === "object") {
+    const index = data.values.push(expression) - 1;
+    return `${prefix}<!--abydon.${index}-->`;
+  }
+  return `${prefix}${expression}`;
+}
+function html(strings, ...values) {
+  return new Fragment(strings, values);
+}
+function parse(data) {
+  const { length } = data.strings;
+  let template = "";
+  for (let index = 0;index < length; index += 1) {
+    template += handleExpression(data, data.strings[index], data.expressions[index]);
+  }
+  return template;
+}
+export {
+  parse,
+  html
+};