@design-edito/tools 0.1.30 → 0.1.32

package/chunks/chunk-SNJJII7A.js

@@ -0,0 +1,65 @@
+import {
+  isFalsy
+} from "./chunk-QXAJXTXV.js";
+
+// src/agnostic/misc/cast/index.ts
+var Cast;
+((Cast2) => {
+  function toBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "string") {
+      if (value.toLowerCase().trim() === "true") return true;
+      return false;
+    }
+    return !isFalsy(value);
+  }
+  Cast2.toBoolean = toBoolean;
+  function toNumber(value) {
+    if (typeof value === "number") return value;
+    if (typeof value === "string") return parseFloat(value);
+    return 0;
+  }
+  Cast2.toNumber = toNumber;
+  function toString(value) {
+    if (typeof value === "string") return value;
+    return String(value);
+  }
+  Cast2.toString = toString;
+  function toNull(_value) {
+    return null;
+  }
+  Cast2.toNull = toNull;
+  function toArray(value) {
+    if (Array.isArray(value)) return value;
+    if (typeof value === "object" && value !== null) return Object.entries(value).map((key, value2) => ({ key, value: value2 }));
+    return [value];
+  }
+  Cast2.toArray = toArray;
+  function toNumberArr(value) {
+    const arrValue = toArray(value);
+    return arrValue.map((val) => toNumber(val));
+  }
+  Cast2.toNumberArr = toNumberArr;
+  function toRecord(value) {
+    const record = {};
+    try {
+      Object.keys(value).forEach((key) => {
+        record[key] = value[key];
+      });
+    } catch (err) {
+      return record;
+    }
+    return record;
+  }
+  Cast2.toRecord = toRecord;
+  function toError(value) {
+    if (value instanceof Error) return value;
+    if (typeof value === "string") return new Error(value);
+    return new Error(toString(value));
+  }
+  Cast2.toError = toError;
+})(Cast || (Cast = {}));
+
+export {
+  Cast
+};

package/chunks/chunk-UDY37VIJ.js

@@ -0,0 +1,22 @@
+import {
+  Crossenv
+} from "./chunk-FR5H2OCV.js";
+import {
+  Errors
+} from "./chunk-2KT7AKRW.js";
+
+// src/shared/errors/index.ts
+var register = Errors.Register.from({
+  ["no-window-document-on-runtime" /* NO_DOCUMENT */]: {
+    message: `Runtime '${Crossenv.detectRuntime()}' does not provide a Document object, cannot complete.`,
+    detailsMaker: () => void 0
+  },
+  ["no-window-document-on-runtime-please-provide" /* NO_DOCUMENT_PLEASE_PROVIDE */]: {
+    message: `Please provide a Document object since none are found on runtime '${Crossenv.detectRuntime()}'`,
+    detailsMaker: (tips) => tips
+  }
+});
+
+export {
+  register
+};

package/chunks/chunk-VFJYLXCI.js

@@ -0,0 +1,23 @@
+import {
+  Cast
+} from "./chunk-SNJJII7A.js";
+
+// src/agnostic/objects/flatten-getters/index.ts
+function flattenGetters(obj) {
+  try {
+    const { entries, getOwnPropertyDescriptors } = Object;
+    const properties = Cast.toRecord(obj);
+    const getters = entries(getOwnPropertyDescriptors(obj)).filter(([_, desc]) => typeof desc.get === "function").map(([key]) => key);
+    const returned = { ...properties };
+    getters.forEach((getter) => {
+      returned[getter] = obj[getter];
+    });
+    return returned;
+  } catch (err) {
+    return {};
+  }
+}
+
+export {
+  flattenGetters
+};

package/chunks/chunk-VKURVIRV.js

@@ -0,0 +1,28 @@
+import {
+  Sanitize
+} from "./chunk-C5753KUP.js";
+import {
+  register
+} from "./chunk-CAMYGA44.js";
+
+// src/agnostic/html/string-to-nodes/index.ts
+function stringToNodes(dirtyStr, options) {
+  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 sanitizeOptions = {
+    ...options?.sanitize,
+    documentObj: options?.sanitize?.documentObj ?? options?.documentObj
+  };
+  const str = options?.sanitize !== void 0 ? Sanitize.sanitize(dirtyStr, sanitizeOptions) : dirtyStr;
+  const wrapperDiv = actualDocument.createElement("div");
+  wrapperDiv.innerHTML = str;
+  const nodes = Array.from(wrapperDiv.childNodes).filter((node) => {
+    const allowedNodeTypes = [Node.ELEMENT_NODE, Node.TEXT_NODE];
+    return allowedNodeTypes.includes(node.nodeType);
+  });
+  return nodes;
+}
+
+export {
+  stringToNodes
+};

package/chunks/chunk-WXXW6YLW.js

@@ -0,0 +1,127 @@
+import {
+  register
+} from "./chunk-UDY37VIJ.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/node/files/index.js

@@ -1,12 +1,12 @@
 import {
   readWrite
 } from "../../chunks/chunk-7DBNMU6N.js";
-import {
-  isInDirectory
-} from "../../chunks/chunk-NRITRUZW.js";
 import {
   Subpaths
 } from "../../chunks/chunk-HGCG2J77.js";
+import {
+  isInDirectory
+} from "../../chunks/chunk-NRITRUZW.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.30",
+  "version": "0.1.32",
   "description": "",
   "author": "Maxime Fabas",
   "license": "ISC",