@design-edito/tools 0.1.29 → 0.1.31

package/chunks/chunk-OVG5RGI3.js

@@ -0,0 +1,29 @@
+import {
+  randomHash,
+  randomHashPattern,
+  randomUUID
+} from "./chunk-75BICI4L.js";
+import {
+  hexChars,
+  randomHexChar
+} from "./chunk-OGBUSUE6.js";
+import {
+  random,
+  randomInt
+} from "./chunk-D3ERTRDW.js";
+
+// src/agnostic/random/index.ts
+var Random;
+((Random2) => {
+  Random2.random = random;
+  Random2.randomInt = randomInt;
+  Random2.hexChars = hexChars;
+  Random2.randomHexChar = randomHexChar;
+  Random2.randomHash = randomHash;
+  Random2.randomHashPattern = randomHashPattern;
+  Random2.randomUUID = randomUUID;
+})(Random || (Random = {}));
+
+export {
+  Random
+};

package/chunks/chunk-RLJOYG64.js

@@ -0,0 +1,33 @@
+// src/agnostic/misc/crossenv/window/index.ts
+var Window;
+((Window2) => {
+  function exists() {
+    return typeof globalThis !== "undefined" && "window" in globalThis;
+  }
+  Window2.exists = exists;
+  let _window = exists() ? globalThis["window"] ?? null : null;
+  function set(customWindow) {
+    _window = customWindow;
+    return customWindow;
+  }
+  Window2.set = set;
+  function unset() {
+    if (exists()) {
+      _window = globalThis["window"];
+    } else {
+      _window = null;
+    }
+    return _window;
+  }
+  Window2.unset = unset;
+  function get() {
+    if (_window !== null) return _window;
+    const message = "Window is undefined. Please call Window.setWindow(windowObj) before using Window.get.";
+    throw new Error(message);
+  }
+  Window2.get = get;
+})(Window || (Window = {}));
+
+export {
+  Window
+};

package/chunks/chunk-S2NMAH7K.js

@@ -0,0 +1,19 @@
+import {
+  Types
+} from "./chunk-LV2VMOWR.js";
+
+// src/agnostic/misc/crossenv/detect-runtime/index.ts
+function detectRuntime() {
+  if (typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.node !== "undefined") return Types.RuntimeName.NODE;
+  if (typeof window !== "undefined" && typeof window.document !== "undefined") return Types.RuntimeName.BROWSER;
+  if (typeof Deno !== "undefined") return Types.RuntimeName.DENO;
+  if (typeof process !== "undefined" && typeof navigator.userAgent === "string" && /ReactNative/.test(navigator.userAgent)) return Types.RuntimeName.REACT_NATIVE;
+  if (typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.version.electron !== "undefined") return Types.RuntimeName.ELECTRON;
+  if (typeof self !== "undefined" && typeof self.addEventListener === "function" && typeof Headers !== "undefined") return Types.RuntimeName.CLOUDFLARE;
+  if (typeof AWS !== "undefined" && typeof AWS.Lambda !== "undefined") return Types.RuntimeName.AWS_LAMBDA;
+  return null;
+}
+
+export {
+  detectRuntime
+};

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-UFKH5WD2.js

@@ -0,0 +1,21 @@
+import {
+  Window
+} from "./chunk-RLJOYG64.js";
+import {
+  detectRuntime
+} from "./chunk-S2NMAH7K.js";
+import {
+  Types
+} from "./chunk-LV2VMOWR.js";
+
+// src/agnostic/misc/crossenv/index.ts
+var Crossenv;
+((Crossenv2) => {
+  Crossenv2.detectRuntime = detectRuntime;
+  Crossenv2.Types = Types;
+  Crossenv2.Window = Window;
+})(Crossenv || (Crossenv = {}));
+
+export {
+  Crossenv
+};

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