@design-edito/tools 0.1.29 → 0.1.30

package/chunks/chunk-WABWQCFE.js

@@ -0,0 +1,127 @@
+import {
+  register
+} from "./chunk-CB52KVOZ.js";
+
+// src/agnostic/html/sanitize/index.ts
+var Sanitize;
+((Sanitize2) => {
+  Sanitize2.defaultOptions = { depth: 20 };
+  function sanitize(inputStr, options = Sanitize2.defaultOptions) {
+    const actualDocument = options.documentObj ?? window.document;
+    if (actualDocument === null) throw register.getError("no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */, "See documentObj in the options object");
+    const wrapperDiv = actualDocument.createElement("div");
+    const { inputFreeTransform } = options;
+    wrapperDiv.innerHTML = inputFreeTransform !== void 0 ? inputFreeTransform(inputStr) : inputStr;
+    const sanitizedWrapper = sanitizeElement(wrapperDiv, options);
+    const returned = sanitizedWrapper?.innerHTML;
+    return returned ?? "";
+  }
+  Sanitize2.sanitize = sanitize;
+  function sanitizeElement(element, options = Sanitize2.defaultOptions) {
+    const actualDocument = options.documentObj ?? window.document;
+    if (actualDocument === null) throw register.getError("no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */, "See documentObj in the options object");
+    const { tagName, attributes, childNodes } = element;
+    const {
+      allowedTags = [],
+      allowedAttributes = {},
+      forbiddenTags = [],
+      forbiddenAttributes = {},
+      depth = 20,
+      verbose = false
+    } = options;
+    if (depth <= 0) {
+      console.warn("Max depth reached");
+      return null;
+    }
+    const normalizedTagName = tagName.toLowerCase().trim();
+    const tagIsInForbidden = forbiddenTags.includes("*") || forbiddenTags.includes(normalizedTagName);
+    if (tagIsInForbidden) {
+      if (verbose === true) console.warn(tagName, "tag is forbidden");
+      return null;
+    }
+    const tagIsInAllowed = allowedTags.includes("*") || allowedTags.includes(normalizedTagName);
+    if (!tagIsInAllowed) {
+      if (verbose === true) console.warn(tagName, "tag is not allowed");
+      return null;
+    }
+    const returnedElement = actualDocument.createElement(tagName);
+    const returnedAttributes = Array.from(attributes).filter(({ name: attributeName, value: attributeValue }) => {
+      const allTagsForbiddenAttributes = forbiddenAttributes["*"] ?? [];
+      const thisTagForbiddenAttributes = forbiddenAttributes[normalizedTagName] ?? [];
+      const mergedForbiddenAttributes = [...allTagsForbiddenAttributes, ...thisTagForbiddenAttributes];
+      const isInForbidden = mergedForbiddenAttributes.some(({
+        attributeName: nameTester,
+        attributeValues: valTesters
+      }) => {
+        if (typeof nameTester === "string" && nameTester !== "*" && attributeName !== nameTester) return false;
+        if (typeof nameTester !== "string" && !nameTester.test(attributeName)) return false;
+        if (valTesters === void 0) {
+          if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
+          return true;
+        }
+        if (valTesters.includes("*")) {
+          if (verbose === true) console.warn(attributeName, "attribute on", tagName, "tag is forbidden");
+          return true;
+        }
+        return valTesters.some((valTester) => {
+          if (typeof valTester === "string" && attributeValue === valTester) {
+            if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
+            return true;
+          }
+          if (typeof valTester !== "string" && valTester.test(attributeValue)) {
+            if (verbose === true) console.warn(attributeValue, "value for", attributeName, "attribute on", tagName, "tag is forbidden. Rule:", valTester);
+            return true;
+          }
+          return false;
+        });
+      });
+      if (isInForbidden) return false;
+      const allTagsAllowedAttributes = allowedAttributes["*"] ?? [];
+      const thisTagAllowedAttributes = allowedAttributes[normalizedTagName] ?? [];
+      const mergedAllowedAttributes = [...allTagsAllowedAttributes, ...thisTagAllowedAttributes];
+      let latestNotAllowedReason = [tagName, "has no allowed attributes"];
+      const isInAllowed = mergedAllowedAttributes.some(({
+        attributeName: nameTester,
+        attributeValues: valTesters
+      }) => {
+        if (typeof nameTester === "string" && nameTester !== "*" && attributeName !== nameTester) {
+          latestNotAllowedReason = [attributeName, "attribute on", tagName, "tag is not allowed"];
+          return false;
+        }
+        if (typeof nameTester !== "string" && !nameTester.test(attributeName)) {
+          latestNotAllowedReason = [attributeName, "attribute on", tagName, "tag is not allowed"];
+          return false;
+        }
+        if (valTesters === void 0) return true;
+        if (valTesters.includes("*")) return true;
+        return valTesters.some((valTester) => {
+          if (typeof valTester === "string" && attributeValue === valTester) return true;
+          if (typeof valTester !== "string" && valTester.test(attributeValue)) return true;
+          latestNotAllowedReason = [attributeValue, "value for", attributeName, "attribute on", tagName, "tag is not allowed"];
+          return false;
+        });
+      });
+      if (!isInAllowed) {
+        if (verbose === true) console.warn(...latestNotAllowedReason);
+        return false;
+      }
+      return true;
+    });
+    returnedAttributes.forEach(({ name, value }) => {
+      returnedElement.setAttribute(name, value);
+    });
+    const sanitizedChildNodes = Array.from(childNodes).map((node) => {
+      if (node.nodeType === Node.ELEMENT_NODE) return sanitizeElement(node, { ...options, depth: depth - 1 });
+      else if (node.nodeType === Node.TEXT_NODE) return node;
+      else if (options.keepComments === true && node.nodeType === Node.COMMENT_NODE) return node;
+      return null;
+    }).filter((elt) => elt !== null);
+    returnedElement.replaceChildren(...sanitizedChildNodes);
+    return returnedElement;
+  }
+  Sanitize2.sanitizeElement = sanitizeElement;
+})(Sanitize || (Sanitize = {}));
+
+export {
+  Sanitize
+};

package/chunks/chunk-YP64J65L.js

@@ -0,0 +1,17 @@
+// src/agnostic/objects/record-format/index.ts
+async function recordFormat(input, format) {
+  const result = {};
+  for (const key in format) {
+    const formatter = format[key];
+    if (typeof formatter === "function") {
+      result[key] = await formatter(input[key]);
+    } else {
+      result[key] = formatter;
+    }
+  }
+  return result;
+}
+
+export {
+  recordFormat
+};

package/chunks/chunk-ZCPGE7H7.js

@@ -0,0 +1,64 @@
+import {
+  Window
+} from "./chunk-RLJOYG64.js";
+
+// src/agnostic/html/hyper-json/serialize/index.ts
+var Serialize;
+((Serialize2) => {
+  function serialize(value) {
+    const { Text, Element, NodeList } = Window.get();
+    if (value === null) return { type: "null", value: null };
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") return { type: typeof value, value };
+    if (value instanceof Text) return { type: "text", value: value.textContent ?? "" };
+    if (value instanceof Element) return { type: "text", value: value.outerHTML };
+    if (value instanceof NodeList) return {
+      type: "text",
+      value: Array.from(value).map((e) => {
+        if (e instanceof Text) return e.textContent;
+        return e.outerHTML;
+      }).join("")
+    };
+    if (Array.isArray(value)) return { type: "array", value: value.map(serialize) };
+    if (typeof value === "function") return { type: "transformer", value };
+    return {
+      type: "record",
+      value: Object.entries(value).reduce((reduced, [key, val]) => ({
+        ...reduced,
+        [key]: serialize(val)
+      }), {})
+    };
+  }
+  Serialize2.serialize = serialize;
+  function deserialize(serialized) {
+    const { document } = Window.get();
+    if (serialized.type === "null") return null;
+    if (serialized.type === "boolean") return serialized.value;
+    if (serialized.type === "number") return serialized.value;
+    if (serialized.type === "string") return serialized.value;
+    if (serialized.type === "text") return document.createTextNode(serialized.value);
+    if (serialized.type === "element") {
+      const elt = document.createElement("div");
+      elt.innerHTML = serialized.value;
+      const firstChild = elt.firstElementChild;
+      return firstChild ?? document.createElement("div");
+    }
+    if (serialized.type === "nodelist") {
+      const elt = document.createElement("div");
+      elt.innerHTML = serialized.value;
+      return elt.childNodes;
+    }
+    if (serialized.type === "array") return serialized.value.map((val) => deserialize(val));
+    if (serialized.type === "transformer") return serialized.value;
+    return Object.entries(serialized.value).reduce((reduced, [key, serialized2]) => {
+      return {
+        ...reduced,
+        [key]: deserialize(serialized2)
+      };
+    }, {});
+  }
+  Serialize2.deserialize = deserialize;
+})(Serialize || (Serialize = {}));
+
+export {
+  Serialize
+};

package/node/files/index.js

@@ -1,12 +1,12 @@
 import {
   readWrite
 } from "../../chunks/chunk-7DBNMU6N.js";
-import {
-  Subpaths
-} from "../../chunks/chunk-HGCG2J77.js";
 import {
   isInDirectory
 } from "../../chunks/chunk-NRITRUZW.js";
+import {
+  Subpaths
+} from "../../chunks/chunk-HGCG2J77.js";
 import "../../chunks/chunk-LQFKUNVQ.js";
 
 // src/node/files/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@design-edito/tools",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "",
   "author": "Maxime Fabas",
   "license": "ISC",