@design-edito/tools 0.1.65 → 0.1.68

package/chunks/chunk-LH6Z6NJY.js

@@ -0,0 +1,191 @@
+import {
+  Random
+} from "./chunk-S32K7POB.js";
+import {
+  Arrays
+} from "./chunk-FHHXI6WC.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-LNSDOGTR.js

@@ -0,0 +1,63 @@
+import {
+  lightenColor,
+  setColorLuminance
+} from "./chunk-U57Q62IN.js";
+import {
+  saturateColor,
+  setColorSaturation
+} from "./chunk-MB7HWF22.js";
+import {
+  complementColor
+} from "./chunk-2POD3TAX.js";
+
+// src/node/images/transform/operations/_utils/frame/backgrounds/create-line-background/index.ts
+async function createLineBackground(background, dimensions, palette) {
+  const lineDimensions = {
+    widthPx: dimensions.widthPx,
+    heightPx: Math.round(dimensions.heightPx / background.params.nbLines)
+  };
+  const sharpOverlays = [];
+  const maxPaletteLength = palette.length;
+  const selectedColorIndex = background.params.colors.selectColorPaletteIndex === "first" ? 0 : background.params.colors.selectColorPaletteIndex === "last" ? palette.length - 1 : background.params.colors.selectColorPaletteIndex;
+  for (let i = 0; i < background.params.nbLines; i++) {
+    const indexPalette = Math.min(Math.max(0, selectedColorIndex), maxPaletteLength);
+    const RGBColor = palette[indexPalette] || [0, 0, 0];
+    const primaryRGBColor = applyColorTransformations(RGBColor, background.params.colors.primaryTransformations);
+    const secondaryRGBColor = applyColorTransformations(RGBColor, background.params.colors.secondaryTransformations);
+    const outputRGBColor = i % 2 === 0 ? primaryRGBColor : secondaryRGBColor;
+    const topPx = Math.min(lineDimensions.heightPx * i, dimensions.heightPx);
+    sharpOverlays.push({
+      input: {
+        create: {
+          width: lineDimensions.widthPx,
+          height: i === background.params.nbLines - 1 ? dimensions.heightPx - topPx : lineDimensions.heightPx,
+          channels: 4,
+          background: { r: outputRGBColor[0], g: outputRGBColor[1], b: outputRGBColor[2], alpha: 1 }
+        }
+      },
+      left: 0,
+      top: topPx
+    });
+  }
+  return sharpOverlays;
+}
+function applyColorTransformations(RGBColor, transformations) {
+  transformations.forEach((transformation) => {
+    RGBColor = transformColor(RGBColor, transformation);
+  });
+  return RGBColor;
+}
+function transformColor(RGBColor, transformation) {
+  switch (transformation.type) {
+    case "saturate":
+      return transformation.intensityMode === "add" ? saturateColor(RGBColor, transformation.intensity) : setColorSaturation(RGBColor, transformation.intensity);
+    case "lighten":
+      return transformation.intensityMode === "add" ? lightenColor(RGBColor, transformation.intensity) : setColorLuminance(RGBColor, transformation.intensity);
+    case "complement":
+      return complementColor(RGBColor);
+  }
+}
+
+export {
+  createLineBackground
+};

package/chunks/chunk-LSOHLSF5.js

@@ -0,0 +1,32 @@
+import {
+  colorSchema
+} from "./chunk-U7R6TPHR.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  esm_default
+} from "./chunk-YE67BQQN.js";
+
+// src/node/images/transform/resize/index.ts
+var resizeSchema = esm_default.object({
+  name: esm_default.literal(OperationNames.Resize),
+  params: esm_default.object({
+    width: esm_default.number().min(0),
+    height: esm_default.number().min(0),
+    options: esm_default.object({
+      background: esm_default.optional(colorSchema),
+      fit: esm_default.enum([
+        "contain",
+        "cover",
+        "fill",
+        "inside",
+        "outside"
+      ]).optional()
+    }).optional()
+  })
+});
+
+export {
+  resizeSchema
+};

package/chunks/chunk-MFK63FMI.js

@@ -0,0 +1,31 @@
+import {
+  colorSchema
+} from "./chunk-U7R6TPHR.js";
+import {
+  esm_default
+} from "./chunk-YE67BQQN.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/extend/index.ts
+var extendSchema = esm_default.object({
+  name: esm_default.literal(OperationNames.Extend),
+  params: esm_default.object({
+    top: esm_default.number(),
+    left: esm_default.number(),
+    right: esm_default.number(),
+    bottom: esm_default.number(),
+    background: colorSchema,
+    extendWith: esm_default.optional(esm_default.enum([
+      "background",
+      "copy",
+      "repeat",
+      "mirror"
+    ]))
+  })
+});
+
+export {
+  extendSchema
+};

package/chunks/chunk-MKHTR43Q.js

@@ -0,0 +1,231 @@
+import {
+  Transitions
+} from "./chunk-ENMBK6H7.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
+import {
+  randomInt
+} from "./chunk-D3ERTRDW.js";
+
+// src/node/images/transform/operations/_utils/frame/backgrounds/create-tile-background/index.ts
+var DEFAULT_CREATE_BACKGROUND_TILE_PARAMS = {
+  coverageRatio: 0.5,
+  densityA: { min: 0, max: 0 },
+  densityB: { min: 0, max: 0 },
+  format: "random",
+  xEasing: "linear",
+  yEasing: "linear"
+};
+async function createTileBackground(background, dimensions, imageCoordinates, colorPalette) {
+  background = {
+    ...background,
+    params: {
+      ...DEFAULT_CREATE_BACKGROUND_TILE_PARAMS,
+      ...background.params
+    }
+  };
+  const tileCoordinatesList = getPackedTilesCoordinatesList(
+    {
+      x: imageCoordinates.x,
+      y: imageCoordinates.y,
+      w: imageCoordinates.w,
+      h: imageCoordinates.h
+    },
+    dimensions,
+    background.params.coverageRatio,
+    {
+      A: background.params.densityA,
+      B: background.params.densityB
+    },
+    {
+      X: background.params.xEasing,
+      Y: background.params.yEasing
+    },
+    background.params.format
+  );
+  return createSharpOverlaysFromCoordinatesList(
+    tileCoordinatesList,
+    colorPalette
+  );
+}
+function getPackedTilesCoordinatesList(coordinatesToAvoid, dimensions, tileCoverageRatio, tileDensity, tileEasing, tileFormat) {
+  const areaCoordinatesList = [];
+  const baseFormat = {
+    nbCells: 9,
+    cellAvoidIndex: 4,
+    nbRows: 3,
+    nbColumns: 3
+  };
+  const positionsToAvoid = {
+    top: Math.ceil(coordinatesToAvoid.y),
+    bottom: Math.ceil(coordinatesToAvoid.y + coordinatesToAvoid.h),
+    left: Math.ceil(coordinatesToAvoid.x),
+    right: Math.ceil(coordinatesToAvoid.x + coordinatesToAvoid.w)
+  };
+  for (let i = 0; i < baseFormat.nbCells; i++) {
+    if (i === baseFormat.cellAvoidIndex) {
+      continue;
+    }
+    const middleColumn = i % baseFormat.nbColumns === 1;
+    const rightColumn = i % baseFormat.nbColumns === 2;
+    const topRow = i < baseFormat.nbRows;
+    const middleRow = !topRow && i < baseFormat.nbRows * 2;
+    const bottomRow = !topRow && !middleRow;
+    areaCoordinatesList[i] = { x: 0, y: 0, w: positionsToAvoid.left, h: positionsToAvoid.top };
+    if (middleColumn) {
+      areaCoordinatesList[i].x = positionsToAvoid.left;
+      areaCoordinatesList[i].w = coordinatesToAvoid.w;
+    }
+    if (rightColumn) {
+      areaCoordinatesList[i].x = positionsToAvoid.right;
+    }
+    if (middleRow) {
+      areaCoordinatesList[i].y = positionsToAvoid.top;
+      areaCoordinatesList[i].h = coordinatesToAvoid.h;
+    }
+    if (bottomRow) {
+      areaCoordinatesList[i].y = positionsToAvoid.bottom;
+      areaCoordinatesList[i].h = dimensions.heightPx - positionsToAvoid.bottom;
+    }
+  }
+  const filteredAreaCoordinatesList = shuffle(areaCoordinatesList.filter((areaCoordinate) => areaCoordinate.w !== 0 && areaCoordinate.h !== 0));
+  const subTiles = [];
+  const nbAreas = filteredAreaCoordinatesList.length;
+  const nbAreasToCover = Math.round(nbAreas * tileCoverageRatio);
+  if (tileDensity.A.min > 1 || tileDensity.A.max > 1 || tileDensity.B.min > 1 || tileDensity.B.max > 1) {
+    filteredAreaCoordinatesList.forEach((areaCoordinates, index) => {
+      if (index > nbAreasToCover) {
+        subTiles.push(areaCoordinates);
+        return;
+      }
+      const { nbRows, nbColumns } = getNbRowsAndColumnsForFormat(
+        randomInt(tileDensity.A.min, tileDensity.A.max) || 0,
+        randomInt(tileDensity.B.min, tileDensity.B.max) || 0,
+        { widthPx: areaCoordinates.w, heightPx: areaCoordinates.h },
+        tileFormat
+      );
+      const XEasingFunc = (tileEasing.X && tileEasing.X in Transitions.easings ? Transitions.easings[tileEasing.X] : Transitions.easings.linear) || function(x) {
+        return x;
+      };
+      const YEasingFunc = (tileEasing.Y in Transitions.easings ? Transitions.easings[tileEasing.Y] : Transitions.easings.linear) || function(x) {
+        return x;
+      };
+      const tiles = [];
+      for (let i = 0; i < nbRows; i++) {
+        for (let j = 0; j < nbColumns; j++) {
+          const columnI = j;
+          const rowI = i;
+          const x = Math.ceil(areaCoordinates.w * XEasingFunc(columnI / nbColumns));
+          const y = Math.ceil(areaCoordinates.h * YEasingFunc(rowI / nbRows));
+          tiles.push({
+            x: areaCoordinates.x + x,
+            y: areaCoordinates.y + y
+          });
+        }
+      }
+      const nbTiles = tiles.length;
+      tiles.forEach((subTileCoord, i) => {
+        const tileNum = i + 1;
+        const nextTileX = tileNum % nbColumns > 0 ? tiles[i + 1] : null;
+        const nextTileY = i + nbColumns < nbTiles ? tiles[i + nbColumns] : null;
+        const subTileBounds = {
+          x: nextTileX ? nextTileX.x : areaCoordinates.x + areaCoordinates.w,
+          y: nextTileY ? nextTileY.y : areaCoordinates.y + areaCoordinates.h
+        };
+        subTiles.push({
+          x: subTileCoord.x,
+          y: subTileCoord.y,
+          w: subTileBounds.x - subTileCoord.x,
+          h: subTileBounds.y - subTileCoord.y
+        });
+      });
+    });
+  }
+  return (subTiles.length ? subTiles : filteredAreaCoordinatesList).map((tile) => ({
+    w: clamp(tile.w, 0, dimensions.widthPx),
+    h: clamp(tile.h, 0, dimensions.heightPx),
+    x: clamp(tile.x, 0, dimensions.widthPx),
+    y: clamp(tile.y, 0, dimensions.heightPx)
+  })).filter((tile) => tile.w > 0 && tile.h > 0);
+}
+function getNbRowsAndColumnsForFormat(tileDensityA, tileDensityB, tileDimensions, tileFormat) {
+  switch (tileFormat) {
+    case "random":
+      const random = Math.random() > Math.random();
+      return {
+        nbRows: random ? tileDensityA : tileDensityB,
+        nbColumns: random ? tileDensityB : tileDensityA
+      };
+    case "portrait":
+      return {
+        nbRows: tileDensityA,
+        nbColumns: tileDensityB
+      };
+    case "landscape":
+      return {
+        nbRows: tileDensityB,
+        nbColumns: tileDensityA
+      };
+    default:
+      return {
+        nbRows: tileDimensions.widthPx > tileDimensions.heightPx ? tileDensityA : tileDensityB,
+        nbColumns: tileDimensions.widthPx > tileDimensions.heightPx ? tileDensityB : tileDensityA
+      };
+  }
+}
+function createSharpOverlaysFromCoordinatesList(tileCoordinatesList, colorPalette) {
+  let usedColorsIndexes = [];
+  const colorPaletteLength = colorPalette.length;
+  const getRGBColor = () => {
+    const getUnusedColorIndex = () => {
+      const paletteIndex = randomInt(0, colorPaletteLength) || 0;
+      resetUnusedColorIndexesIfNeeded();
+      if (usedColorsIndexes.includes(paletteIndex)) {
+        return getUnusedColorIndex();
+      }
+      usedColorsIndexes.push(paletteIndex);
+      return paletteIndex;
+    };
+    const resetUnusedColorIndexesIfNeeded = () => {
+      if (usedColorsIndexes.length !== colorPaletteLength) {
+        return;
+      }
+      usedColorsIndexes = [];
+    };
+    const colorPaletteIndex = getUnusedColorIndex();
+    const RGBColor = colorPalette[colorPaletteIndex];
+    if (!RGBColor) {
+      return [0, 0, 0];
+    }
+    return RGBColor;
+  };
+  return tileCoordinatesList.map((tileCoordinates) => {
+    const RGBColor = getRGBColor();
+    return {
+      top: Math.floor(tileCoordinates.y),
+      left: Math.floor(tileCoordinates.x),
+      input: {
+        create: {
+          width: Math.round(tileCoordinates.w),
+          height: Math.round(tileCoordinates.h),
+          channels: 4,
+          background: {
+            r: RGBColor[0],
+            g: RGBColor[1],
+            b: RGBColor[2],
+            alpha: 1
+          }
+        }
+      }
+    };
+  });
+}
+
+export {
+  DEFAULT_CREATE_BACKGROUND_TILE_PARAMS,
+  createTileBackground
+};

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
+};