@design-edito/tools 0.2.0 → 0.2.1

package/chunks/chunk-MROXW73J.js

@@ -0,0 +1,168 @@
+import {
+  isSaturateOperationParams,
+  saturate
+} from "./chunk-UPSIFUMS.js";
+import {
+  extend,
+  isExtendOperationParams
+} from "./chunk-MMGAJ7EW.js";
+import {
+  flop
+} from "./chunk-YA2YCZUF.js";
+import {
+  isLevelOperationParams,
+  level
+} from "./chunk-T3D55RRI.js";
+import {
+  hue,
+  isHueOperationParams
+} from "./chunk-3YW3KBO5.js";
+import {
+  isLightenOperationParams,
+  lighten
+} from "./chunk-2FC5KUMS.js";
+import {
+  isNormalizeOperationParams,
+  normalize
+} from "./chunk-7NOLNBF6.js";
+import {
+  isResizeOperationParams,
+  resize
+} from "./chunk-FORJXSIW.js";
+import {
+  isRotateOperationParams,
+  rotate
+} from "./chunk-KZKHIPWQ.js";
+import {
+  blur,
+  isBlurOperationParams
+} from "./chunk-PJFSPYPO.js";
+import {
+  flatten,
+  isFlattenOperationParams
+} from "./chunk-VTDLFWOD.js";
+import {
+  brighten,
+  isBrightenOperationParams
+} from "./chunk-YTGB73UX.js";
+import {
+  flip
+} from "./chunk-WNDMYNDU.js";
+import {
+  extract,
+  isExtractOperationParams
+} from "./chunk-5JX7EWIW.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/transform/index.ts
+var transform_exports = {};
+__export(transform_exports, {
+  OpName: () => OpName,
+  isOperationDescriptor: () => isOperationDescriptor,
+  transform: () => transform
+});
+import sharp from "sharp";
+var OpName = /* @__PURE__ */ ((OpName2) => {
+  OpName2["BLUR"] = "blur";
+  OpName2["BRIGHTEN"] = "brighten";
+  OpName2["EXTEND"] = "extend";
+  OpName2["EXTRACT"] = "extract";
+  OpName2["FLATTEN"] = "flatten";
+  OpName2["FLIP"] = "flip";
+  OpName2["FLOP"] = "flop";
+  OpName2["HUE"] = "hue";
+  OpName2["LEVEL"] = "level";
+  OpName2["LIGHTEN"] = "lighten";
+  OpName2["NORMALIZE"] = "normalize";
+  OpName2["RESIZE"] = "resize";
+  OpName2["ROTATE"] = "rotate";
+  OpName2["SATURATE"] = "saturate";
+  return OpName2;
+})(OpName || {});
+function isOperationDescriptor(obj) {
+  if (typeof obj !== "object" || obj === null) return false;
+  if (!("name" in obj)) return false;
+  if (obj.name === "blur" /* BLUR */) return isBlurOperationParams(obj);
+  if (obj.name === "brighten" /* BRIGHTEN */) return isBrightenOperationParams(obj);
+  if (obj.name === "extend" /* EXTEND */) return isExtendOperationParams(obj);
+  if (obj.name === "extract" /* EXTRACT */) return isExtractOperationParams(obj);
+  if (obj.name === "flatten" /* FLATTEN */) return isFlattenOperationParams(obj);
+  if (obj.name === "flip" /* FLIP */) return true;
+  if (obj.name === "flop" /* FLOP */) return true;
+  if (obj.name === "hue" /* HUE */) return isHueOperationParams(obj);
+  if (obj.name === "level" /* LEVEL */) return isLevelOperationParams(obj);
+  if (obj.name === "lighten" /* LIGHTEN */) return isLightenOperationParams(obj);
+  if (obj.name === "normalize" /* NORMALIZE */) return isNormalizeOperationParams(obj);
+  if (obj.name === "resize" /* RESIZE */) return isResizeOperationParams(obj);
+  if (obj.name === "rotate" /* ROTATE */) return isRotateOperationParams(obj);
+  if (obj.name === "saturate" /* SATURATE */) return isSaturateOperationParams(obj);
+  return false;
+}
+async function transform(input, operationsSequence) {
+  if (Buffer.isBuffer(input)) return transformBuffer(input, operationsSequence);
+  return transformSharpInstance(input, operationsSequence);
+}
+async function transformSharpInstance(sharpInstance, operationsSequence) {
+  for (const operation of operationsSequence) {
+    switch (operation.name) {
+      case "blur" /* BLUR */:
+        sharpInstance = await blur(sharpInstance, operation);
+        break;
+      case "brighten" /* BRIGHTEN */:
+        sharpInstance = await brighten(sharpInstance, operation);
+        break;
+      case "extend" /* EXTEND */:
+        sharpInstance = await extend(sharpInstance, operation);
+        break;
+      case "extract" /* EXTRACT */:
+        sharpInstance = await extract(sharpInstance, operation);
+        break;
+      case "flatten" /* FLATTEN */:
+        sharpInstance = await flatten(sharpInstance, operation);
+        break;
+      case "flip" /* FLIP */:
+        sharpInstance = await flip(sharpInstance);
+        break;
+      case "flop" /* FLOP */:
+        sharpInstance = await flop(sharpInstance);
+        break;
+      case "hue" /* HUE */:
+        sharpInstance = await hue(sharpInstance, operation);
+        break;
+      case "level" /* LEVEL */:
+        sharpInstance = await level(sharpInstance, operation);
+        break;
+      case "lighten" /* LIGHTEN */:
+        sharpInstance = await lighten(sharpInstance, operation);
+        break;
+      case "normalize" /* NORMALIZE */:
+        sharpInstance = await normalize(sharpInstance, operation);
+        break;
+      case "resize" /* RESIZE */:
+        sharpInstance = await resize(sharpInstance, operation);
+        break;
+      case "rotate" /* ROTATE */:
+        sharpInstance = await rotate(sharpInstance, operation);
+        break;
+      case "saturate" /* SATURATE */:
+        sharpInstance = await saturate(sharpInstance, operation);
+        break;
+      default:
+        sharpInstance = sharpInstance;
+    }
+  }
+  return sharpInstance;
+}
+async function transformBuffer(fileBuffer, operationsSequence) {
+  const sharpInstance = sharp(fileBuffer);
+  return transformSharpInstance(sharpInstance, operationsSequence);
+}
+
+export {
+  OpName,
+  isOperationDescriptor,
+  transform,
+  transform_exports
+};

package/chunks/chunk-MTT7TVR3.js

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

@@ -0,0 +1,29 @@
+import {
+  register
+} from "./chunk-WC2LQPQP.js";
+
+// src/agnostic/arrays/random-pick/index.ts
+function randomPick(arr, exclude = []) {
+  const filteredArr = [...arr].filter((elt) => !exclude.includes(elt));
+  const length = filteredArr.length;
+  if (length === 0) throw register.getError("impossible-to-pick-in-array" /* IMPOSSIBLE_TO_PICK_IN_ARRAY */, arr);
+  const pos = Math.floor(Math.random() * length);
+  const found = filteredArr[pos];
+  return found;
+}
+function randomPickMany(howMuch, arr, exclude = []) {
+  const grindedArr = [...arr];
+  const pickedSelection = [];
+  for (let i = 0; i < howMuch; i++) {
+    const picked = randomPick(grindedArr, exclude);
+    const indexOfPicked = grindedArr.indexOf(picked);
+    grindedArr.splice(indexOfPicked, 1);
+    pickedSelection.push(picked);
+  }
+  return pickedSelection;
+}
+
+export {
+  randomPick,
+  randomPickMany
+};

package/chunks/chunk-NUGVP2MM.js

@@ -0,0 +1,191 @@
+import {
+  Arrays
+} from "./chunk-3SRJYILO.js";
+import {
+  Random
+} from "./chunk-S32K7POB.js";
+
+// src/agnostic/misc/lorem-ipsum/index.ts
+var LoremIpsum;
+((LoremIpsum2) => {
+  LoremIpsum2.words = [
+    "a",
+    "ac",
+    "accumsan",
+    "adipiscing",
+    "aenean",
+    "aliquam",
+    "aliquet",
+    "amet",
+    "ante",
+    "arcu",
+    "at",
+    "auctor",
+    "augue",
+    "bibendum",
+    "blandit",
+    "condimentum",
+    "consectetur",
+    "consequat",
+    "convallis",
+    "cras",
+    "curabitur",
+    "cursus",
+    "dapibus",
+    "diam",
+    "dictum",
+    "dictumst",
+    "dignissim",
+    "dolor",
+    "donec",
+    "dui",
+    "duis",
+    "efficitur",
+    "egestas",
+    "eget",
+    "eleifend",
+    "elementum",
+    "elit",
+    "enim",
+    "erat",
+    "eros",
+    "est",
+    "et",
+    "eu",
+    "euismod",
+    "ex",
+    "facilisis",
+    "faucibus",
+    "felis",
+    "feugiat",
+    "finibus",
+    "fringilla",
+    "fusce",
+    "gravida",
+    "habitasse",
+    "hac",
+    "hendrerit",
+    "iaculis",
+    "id",
+    "imperdiet",
+    "in",
+    "integer",
+    "interdum",
+    "ipsum",
+    "justo",
+    "lacinia",
+    "lacus",
+    "laoreet",
+    "lectus",
+    "leo",
+    "libero",
+    "ligula",
+    "lobortis",
+    "lorem",
+    "luctus",
+    "maecenas",
+    "magna",
+    "malesuada",
+    "massa",
+    "mattis",
+    "mauris",
+    "maximus",
+    "metus",
+    "mi",
+    "molestie",
+    "mollis",
+    "morbi",
+    "nam",
+    "nec",
+    "neque",
+    "nibh",
+    "nisi",
+    "nisl",
+    "non",
+    "nulla",
+    "nullam",
+    "nunc",
+    "odio",
+    "orci",
+    "ornare",
+    "pellentesque",
+    "pharetra",
+    "phasellus",
+    "placerat",
+    "platea",
+    "porta",
+    "porttitor",
+    "posuere",
+    "praesent",
+    "pulvinar",
+    "purus",
+    "quam",
+    "quis",
+    "quisque",
+    "risus",
+    "rutrum",
+    "sagittis",
+    "sapien",
+    "sed",
+    "sem",
+    "semper",
+    "sit",
+    "sodales",
+    "sollicitudin",
+    "suscipit",
+    "suspendisse",
+    "tellus",
+    "tempor",
+    "tempus",
+    "tincidunt",
+    "tortor",
+    "tristique",
+    "turpis",
+    "ultrices",
+    "ultricies",
+    "urna",
+    "ut",
+    "vehicula",
+    "vel",
+    "velit",
+    "venenatis",
+    "vestibulum",
+    "vitae",
+    "vivamus",
+    "viverra",
+    "volutpat",
+    "vulputate"
+  ];
+  LoremIpsum2.generateSentence = (wordCount) => {
+    const resultArr = [];
+    let currentWordCound = wordCount;
+    for (let i = 0; i < currentWordCound; i++) {
+      const picked = Arrays.randomPick(LoremIpsum2.words);
+      if (typeof picked === "string") resultArr.push(picked);
+      else {
+        currentWordCound += 1;
+      }
+    }
+    const [firstWord, ...otherWords] = resultArr;
+    if (firstWord === void 0) return "";
+    const capFirstLetter = firstWord?.charAt(0).toUpperCase();
+    const restOfFirstWord = firstWord?.slice(1);
+    const sentence = [
+      `${capFirstLetter}${restOfFirstWord}`,
+      ...otherWords
+    ].join(" ");
+    return `${sentence}.`;
+  };
+  LoremIpsum2.generateSentences = (sentencesCount, maxSentenceLength = 12, minSentenceLength = 4) => {
+    const sentences = [];
+    for (let i = 0; i < sentencesCount; i++) {
+      const length = Random.randomInt(maxSentenceLength, minSentenceLength) ?? 8;
+      sentences.push((0, LoremIpsum2.generateSentence)(length));
+    }
+    return sentences;
+  };
+})(LoremIpsum || (LoremIpsum = {}));
+
+export {
+  LoremIpsum
+};

package/chunks/chunk-NYVARFI7.js

@@ -0,0 +1,20 @@
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/get-metadata/index.ts
+var get_metadata_exports = {};
+__export(get_metadata_exports, {
+  getMetadata: () => getMetadata
+});
+import { Buffer } from "node:buffer";
+import sharp from "sharp";
+async function getMetadata(imageInput) {
+  const sharpInstance = Buffer.isBuffer(imageInput) ? sharp(imageInput) : imageInput;
+  return sharpInstance.metadata();
+}
+
+export {
+  getMetadata,
+  get_metadata_exports
+};

package/chunks/chunk-ODDE3NBH.js

@@ -0,0 +1,24 @@
+import {
+  bucket_exports
+} from "./chunk-BD56ZAYF.js";
+import {
+  file_exports
+} from "./chunk-XYVNT74Y.js";
+import {
+  directory_exports
+} from "./chunk-WJ3XV35I.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  Bucket: () => bucket_exports,
+  Directory: () => directory_exports,
+  File: () => file_exports
+});
+
+export {
+  storage_exports
+};

package/chunks/chunk-PJFSPYPO.js

@@ -0,0 +1,16 @@
+import {
+  zod_default
+} from "./chunk-OT4SVHDX.js";
+
+// src/node/images/transform/operations/blur/index.ts
+function isBlurOperationParams(obj) {
+  return zod_default.object({ sigma: zod_default.number() }).safeParse(obj).success;
+}
+async function blur(sharpInstance, params) {
+  return sharpInstance.blur(params.sigma);
+}
+
+export {
+  isBlurOperationParams,
+  blur
+};

package/chunks/chunk-QPG45V6W.js

@@ -0,0 +1,56 @@
+import {
+  move_file_exports
+} from "./chunk-646R6BQZ.js";
+import {
+  remove_file_exports
+} from "./chunk-H4LW6FP3.js";
+import {
+  move_dir_exports
+} from "./chunk-FS6LRTDK.js";
+import {
+  remove_dir_exports
+} from "./chunk-CA3UPHYO.js";
+import {
+  stat_file_exports
+} from "./chunk-UK4HNSEJ.js";
+import {
+  upload_file_exports
+} from "./chunk-NOLQR5RW.js";
+import {
+  copy_dir_exports
+} from "./chunk-6NLNUGBI.js";
+import {
+  copy_file_exports
+} from "./chunk-OA7Y2A5T.js";
+import {
+  download_file_exports
+} from "./chunk-EOTOFHUR.js";
+import {
+  exists_file_exports
+} from "./chunk-24ZUWYIR.js";
+import {
+  list_dir_exports
+} from "./chunk-DPQRXSZH.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  CopyDir: () => copy_dir_exports,
+  CopyFile: () => copy_file_exports,
+  DownloadFile: () => download_file_exports,
+  ExistsFile: () => exists_file_exports,
+  ListDir: () => list_dir_exports,
+  MoveDir: () => move_dir_exports,
+  MoveFile: () => move_file_exports,
+  RemoveDir: () => remove_dir_exports,
+  RemoveFile: () => remove_file_exports,
+  StatFile: () => stat_file_exports,
+  UploadFile: () => upload_file_exports
+});
+
+export {
+  operations_exports
+};