@design-edito/tools 0.1.53 → 0.1.54

package/agnostic/random/uuid/index.js

@@ -4,7 +4,7 @@ import {
   randomUUID
 } from "../../../chunks/chunk-75BICI4L.js";
 import "../../../chunks/chunk-OGBUSUE6.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   randomHash,
   randomHashPattern,

package/agnostic/regexps/index.js

@@ -1,4 +1,4 @@
-import "../../chunks/chunk-XCBH6NLF.js";
+import "../../chunks/chunk-WSFCRVEQ.js";
 
 // src/agnostic/regexps/index.ts
 var Regexps;

package/agnostic/strings/char-codes/index.js

@@ -1,7 +1,7 @@
 import {
   CharCodes
 } from "../../../chunks/chunk-34U4HX4V.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   CharCodes
 };

package/agnostic/strings/index.js

@@ -1,25 +1,25 @@
 import {
   CharCodes
 } from "../../chunks/chunk-34U4HX4V.js";
-import {
-  normalizeIndent
-} from "../../chunks/chunk-JQXNEJAP.js";
 import {
   matches,
   matchesEvery,
   matchesSome
 } from "../../chunks/chunk-LQFKUNVQ.js";
+import {
+  toAlphanum
+} from "../../chunks/chunk-COVPTTAD.js";
 import {
   replaceAll
 } from "../../chunks/chunk-ZTDVUXPR.js";
+import {
+  normalizeIndent
+} from "../../chunks/chunk-JQXNEJAP.js";
 import {
   trimEnd,
   trimStart
 } from "../../chunks/chunk-6XL25OZX.js";
-import {
-  toAlphanum
-} from "../../chunks/chunk-COVPTTAD.js";
-import "../../chunks/chunk-XCBH6NLF.js";
+import "../../chunks/chunk-WSFCRVEQ.js";
 
 // src/agnostic/strings/index.ts
 var Strings;

package/agnostic/strings/matches/index.js

@@ -3,7 +3,7 @@ import {
   matchesEvery,
   matchesSome
 } from "../../../chunks/chunk-LQFKUNVQ.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   matches,
   matchesEvery,

package/agnostic/strings/normalize-indent/index.js

@@ -1,7 +1,7 @@
 import {
   normalizeIndent
 } from "../../../chunks/chunk-JQXNEJAP.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   normalizeIndent
 };

package/agnostic/strings/replace-all/index.js

@@ -1,7 +1,7 @@
 import {
   replaceAll
 } from "../../../chunks/chunk-ZTDVUXPR.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   replaceAll
 };

package/agnostic/strings/to-alphanum/index.js

@@ -1,7 +1,7 @@
 import {
   toAlphanum
 } from "../../../chunks/chunk-COVPTTAD.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   toAlphanum
 };

package/agnostic/strings/trim/index.js

@@ -2,7 +2,7 @@ import {
   trimEnd,
   trimStart
 } from "../../../chunks/chunk-6XL25OZX.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   trimEnd,
   trimStart

package/agnostic/time/dates/format-date/index.js

@@ -1,7 +1,7 @@
 import {
   formatDate
 } from "../../../../chunks/chunk-YQWZ3EP2.js";
-import "../../../../chunks/chunk-XCBH6NLF.js";
+import "../../../../chunks/chunk-WSFCRVEQ.js";
 export {
   formatDate
 };

package/agnostic/time/dates/index.js

@@ -2,7 +2,7 @@ import {
   Dates
 } from "../../../chunks/chunk-FZOU4OAW.js";
 import "../../../chunks/chunk-YQWZ3EP2.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   Dates
 };

package/agnostic/time/duration/index.js

@@ -1,7 +1,7 @@
 import {
   Duration
 } from "../../../chunks/chunk-6NYUQXJT.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   Duration
 };

package/agnostic/time/index.js

@@ -2,19 +2,19 @@ import {
   Dates
 } from "../../chunks/chunk-FZOU4OAW.js";
 import "../../chunks/chunk-YQWZ3EP2.js";
-import {
-  timeout
-} from "../../chunks/chunk-Z7ZDDBV5.js";
 import {
   Duration
 } from "../../chunks/chunk-6NYUQXJT.js";
+import {
+  timeout
+} from "../../chunks/chunk-Z7ZDDBV5.js";
 import {
   Transitions
 } from "../../chunks/chunk-ENMBK6H7.js";
 import {
   wait
 } from "../../chunks/chunk-4CIS3R7T.js";
-import "../../chunks/chunk-XCBH6NLF.js";
+import "../../chunks/chunk-WSFCRVEQ.js";
 
 // src/agnostic/time/index.ts
 var Time;

package/agnostic/time/timeout/index.js

@@ -1,7 +1,7 @@
 import {
   timeout
 } from "../../../chunks/chunk-Z7ZDDBV5.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   timeout
 };

package/agnostic/time/transitions/index.js

@@ -2,7 +2,7 @@ import {
   Transitions
 } from "../../../chunks/chunk-ENMBK6H7.js";
 import "../../../chunks/chunk-4CIS3R7T.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   Transitions
 };

package/agnostic/time/wait/index.js

@@ -1,7 +1,7 @@
 import {
   wait
 } from "../../../chunks/chunk-4CIS3R7T.js";
-import "../../../chunks/chunk-XCBH6NLF.js";
+import "../../../chunks/chunk-WSFCRVEQ.js";
 export {
   wait
 };

package/chunks/chunk-35W7XRC3.js

@@ -0,0 +1,173 @@
+import {
+  Random
+} from "./chunk-DCKTGQOX.js";
+import {
+  register
+} from "./chunk-P2H6PV4O.js";
+
+// src/agnostic/css/styles-set/index.tsx
+import { Component } from "react";
+import { createRoot as reactCreateRoot } from "react-dom/client";
+import { Fragment, jsx } from "react/jsx-runtime";
+var StylesSet = class _StylesSet {
+  static defaultPrivateIDAttribute = "data-styleset-private-id";
+  static defaultPublicIDAttribute = "data-styleset-public-id";
+  tagsPrivateIDAttribute = _StylesSet.defaultPrivateIDAttribute;
+  tagsPublicIDAttribute = _StylesSet.defaultPublicIDAttribute;
+  _items = /* @__PURE__ */ new Map();
+  get items() {
+    const sortedItemsArray = Array.from(this._items).map(([privateId, item]) => {
+      const targetPosition = this.getTargetPosition(privateId) ?? 0;
+      return { targetPosition, privateId, item };
+    }).sort((a, b) => a.targetPosition - b.targetPosition).map(({ item, privateId }) => [privateId, item]);
+    const sortedItemsMap = new Map(sortedItemsArray);
+    return sortedItemsMap;
+  }
+  getTargetPosition(privateId) {
+    const orderedStyles = Array.from(this._items).map(([privateId2, data]) => ({ privateId: privateId2, data })).sort((a, b) => {
+      const aPos = a.data.position ?? 0;
+      const bPos = b.data.position ?? 0;
+      return aPos - bPos;
+    });
+    const foundIndex = orderedStyles.findIndex((item) => item.privateId === privateId);
+    return foundIndex === -1 ? null : foundIndex;
+  }
+  setTagsPrivateIDAttribute(str) {
+    this.tagsPrivateIDAttribute = str;
+    return this;
+  }
+  setTagsPublicIDAttribute(str) {
+    this.tagsPublicIDAttribute = str;
+    return this;
+  }
+  getById(id) {
+    const found = Array.from(this._items.values()).find((entry) => entry.id === id);
+    if (found === void 0) return void 0;
+    return found;
+  }
+  generateUniquePrivateId() {
+    const existingIds = Array.from(this._items.keys());
+    const generated = Random.randomHash(12);
+    if (existingIds.includes(generated)) return this.generateUniquePrivateId();
+    return generated;
+  }
+  _rendered = /* @__PURE__ */ new Map();
+  render(element) {
+    const root = reactCreateRoot(element);
+    const items = this.items;
+    root.render(/* @__PURE__ */ jsx(
+      StylesSetComp,
+      {
+        items,
+        privateIDAttribute: this.tagsPrivateIDAttribute,
+        publicIDAttribute: this.tagsPublicIDAttribute
+      }
+    ));
+    this._rendered.set(element, root);
+    return this;
+  }
+  unmount(element) {
+    if (!this._rendered.has(element)) return this;
+    const root = this._rendered.get(element);
+    if (root === void 0) return this;
+    root.unmount();
+    this._rendered.delete(element);
+    return this;
+  }
+  updateRendered() {
+    const { items } = this;
+    this._rendered.forEach((root) => root.render(/* @__PURE__ */ jsx(
+      StylesSetComp,
+      {
+        items,
+        privateIDAttribute: this.tagsPrivateIDAttribute,
+        publicIDAttribute: this.tagsPublicIDAttribute
+      }
+    )));
+    return this;
+  }
+  addItem(item, abortIfIdExists = true) {
+    const existing = Array.from(this._items.entries()).map(([privateId2, entry]) => ({ privateId: privateId2, entry })).find(({ entry }) => entry.id !== void 0 && entry.id === item.id);
+    if (existing !== void 0) {
+      if (abortIfIdExists) return this;
+      this._items.delete(existing.privateId);
+    }
+    const privateId = this.generateUniquePrivateId();
+    this._items.set(privateId, item);
+    this.updateRendered();
+    return this;
+  }
+  removeItem(idOrPosition) {
+    if (typeof idOrPosition === "string") {
+      const existing = Array.from(this._items.entries()).map(([privateId, entry]) => ({ privateId, entry })).find(({ entry }) => entry.id !== void 0 && entry.id === idOrPosition);
+      if (existing === void 0) return this;
+      this._items.delete(existing.privateId);
+      this.updateRendered();
+      return this;
+    }
+    const toRemove = Array.from(this._items).map(([privateId, entry]) => ({ privateId, entry })).at(idOrPosition);
+    if (toRemove === void 0) return this;
+    this._items.delete(toRemove.privateId);
+    this.updateRendered();
+    return this;
+  }
+  async getDomString(documentObj) {
+    const actualDocumentObj = documentObj ?? window.document;
+    if (actualDocumentObj === null) throw register.getError("no-window-document-on-runtime" /* NO_DOCUMENT */);
+    return new Promise((resolve) => {
+      const tempElt = actualDocumentObj.createElement("div");
+      const tempRoot = reactCreateRoot(tempElt);
+      const { items } = this;
+      const onRendered = () => {
+        resolve(tempElt.innerHTML);
+        tempRoot.unmount();
+        tempElt.remove();
+      };
+      tempRoot.render(/* @__PURE__ */ jsx(
+        StylesSetComp,
+        {
+          items,
+          privateIDAttribute: this.tagsPrivateIDAttribute,
+          publicIDAttribute: this.tagsPublicIDAttribute,
+          onRendered
+        }
+      ));
+    });
+  }
+};
+var StylesSetComp = class extends Component {
+  componentDidMount() {
+    const { props } = this;
+    const { onRendered } = props;
+    if (onRendered !== void 0) onRendered();
+  }
+  componentDidUpdate() {
+    const { props } = this;
+    const { onRendered } = props;
+    if (onRendered !== void 0) onRendered();
+  }
+  render() {
+    const { props } = this;
+    const items = props.items ?? /* @__PURE__ */ new Map();
+    const pidAttr = props.privateIDAttribute ?? StylesSet.defaultPrivateIDAttribute;
+    const idAttr = props.publicIDAttribute ?? StylesSet.defaultPublicIDAttribute;
+    return /* @__PURE__ */ jsx(Fragment, { children: Array.from(items).map(([privateId, itemData]) => {
+      const customAttributes = { [pidAttr]: privateId, [idAttr]: itemData.id };
+      if (itemData.type === "url") return /* @__PURE__ */ jsx(
+        "link",
+        {
+          onLoad: itemData.onLoad,
+          rel: "stylesheet",
+          href: itemData.content,
+          ...customAttributes
+        }
+      );
+      return /* @__PURE__ */ jsx("style", { ...customAttributes, children: itemData.content });
+    }) });
+  }
+};
+
+export {
+  StylesSet,
+  StylesSetComp
+};

package/chunks/chunk-3GTGE66Y.js

@@ -0,0 +1,32 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/file/move/index.ts
+var move_exports = {};
+__export(move_exports, {
+  move: () => move
+});
+async function move(sourcePath, destinationPath, bucket, options) {
+  const { fileOptions, copyOptions, deleteOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    await file.copy(destinationPath, copyOptions);
+    await file.delete(deleteOptions);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  move,
+  move_exports
+};

package/chunks/chunk-422KBDRV.js

@@ -0,0 +1,203 @@
+import {
+  thumbnails_exports
+} from "./chunk-UVSTFYSD.js";
+
+// src/node/images/transform/area-composition/index.ts
+import sharp from "sharp";
+var DEFAULT_GENERATE_OPTIONS = {
+  formats: ["jpeg"],
+  nbOutputs: 1,
+  imagePosition: "center",
+  imageOccupation: 60,
+  dimensions: { w: 300, h: 500 },
+  palette: ["default"],
+  maxPaletteDensity: 100,
+  extractPaletteDensity: 8,
+  lightenIntensity: 20,
+  saturateIntensity: 20,
+  colorFilterApply: "all",
+  tileDensityA: { min: 1, max: 1 },
+  tileDensityB: { min: 1, max: 1 },
+  tileCoverage: 50,
+  tileFormat: "default",
+  tileXEasing: "none",
+  tileYEasing: "none"
+};
+async function areaCompose(inputSharp, customOptions) {
+  const options = getOptions(customOptions);
+  const inputMetadata = await inputSharp.metadata();
+  const initialDimensions = {
+    w: inputMetadata.width || 0,
+    h: inputMetadata.height || 0
+  };
+  const inputBufferData = await inputSharp.raw().toBuffer();
+  const imagePalette = thumbnails_exports.Colors.extractPaletteFromImage(inputBufferData, initialDimensions, options);
+  const composedPalette = composePalette(imagePalette, options.palette, options.maxPaletteDensity);
+  inputSharp.png({ quality: 100 });
+  const outputDimensions = {
+    w: options.dimensions.w,
+    h: options.dimensions.h
+  };
+  const resizeInputDimensions = getNewInputImageDimensions(outputDimensions, options.imageOccupation);
+  const resizedInput = inputSharp.resize({
+    width: resizeInputDimensions.w,
+    height: resizeInputDimensions.h,
+    fit: "contain",
+    background: { r: 255, g: 255, b: 255, alpha: 0 }
+    // Add a transparent background
+  }).toFormat("png");
+  const resizedInputPositions = getImagePositions(options.imagePosition, resizeInputDimensions, resizeInputDimensions, outputDimensions);
+  const shapesLayout = thumbnails_exports.Layout.packAreasAndTiles(
+    {
+      ...resizedInputPositions,
+      ...resizeInputDimensions
+    },
+    outputDimensions,
+    options.tileCoverage,
+    { A: options.tileDensityA, B: options.tileDensityB },
+    { X: options.tileXEasing, Y: options.tileYEasing }
+  );
+  const sharpShapes = getSharpTilesInputs(shapesLayout, composedPalette);
+  const sharpShapesForComposite = [];
+  for await (const sharpShape of sharpShapes) {
+    ;
+    sharpShapesForComposite.push({
+      input: await sharpShape.input.toFormat("png").toBuffer(),
+      left: sharpShape.left,
+      top: sharpShape.top
+    });
+  }
+  const background = composedPalette[0] || [255, 255, 255];
+  const outputSharp = await createSharpShape(outputDimensions, background).toFormat("webp");
+  const composedSharp = outputSharp.composite([
+    {
+      input: await resizedInput.toFormat("webp").toBuffer(),
+      /* Converting to png to handle alpha */
+      left: Math.round(resizedInputPositions.x),
+      top: Math.round(resizedInputPositions.y)
+    },
+    ...sharpShapesForComposite
+  ]);
+  return await composedSharp.flatten();
+}
+function getOptions(customOptions) {
+  if (!customOptions) {
+    return DEFAULT_GENERATE_OPTIONS;
+  }
+  ;
+  const options = {
+    ...DEFAULT_GENERATE_OPTIONS,
+    ...customOptions
+  };
+  return options;
+}
+function getNewInputImageDimensions(formatDimensions, imageOccupation) {
+  const placeRatio = imageOccupation / 100;
+  return {
+    w: Math.round(formatDimensions.w * placeRatio),
+    h: Math.round(formatDimensions.h * placeRatio)
+  };
+}
+function composePalette(palette, paletteOption, maxPaletteDensity) {
+  let composedPalette = [];
+  if (paletteOption.includes("default-lighten")) {
+    composedPalette = [...composedPalette, ...palette.default.lighten];
+  }
+  if (paletteOption.includes("default-saturate")) {
+    composedPalette = [...composedPalette, ...palette.default.saturate];
+  }
+  if (paletteOption.includes("complementary")) {
+    composedPalette = [...composedPalette, ...palette.complementary.default];
+  }
+  if (paletteOption.includes("complementary-lighten")) {
+    composedPalette = [...composedPalette, ...palette.complementary.lighten];
+  }
+  if (paletteOption.includes("complementary-saturate")) {
+    composedPalette = [...composedPalette, ...palette.complementary.saturate];
+  }
+  if (paletteOption.includes("default") || !composedPalette.length) {
+    composedPalette = [...composedPalette, ...palette.default.default];
+  }
+  const shuffledPalette = thumbnails_exports.Common.shuffleArray(composedPalette);
+  const outputPalette = composedPalette.length > maxPaletteDensity ? shuffledPalette.splice(0, maxPaletteDensity) : shuffledPalette;
+  return outputPalette;
+}
+function getImagePositions(position, resizedImageDimensions, containedImageDimensions, wrapperDimensions) {
+  switch (position) {
+    case "top-left":
+      return thumbnails_exports.Layout.alignTopLeft(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "top-center":
+      return thumbnails_exports.Layout.alignTopCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "top-right":
+      return thumbnails_exports.Layout.alignTopRight(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "left-center":
+      return thumbnails_exports.Layout.alignLeftCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "center":
+      return thumbnails_exports.Layout.alignCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "right-center":
+      return thumbnails_exports.Layout.alignRightCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "bottom-left":
+      return thumbnails_exports.Layout.alignBottomLeft(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "bottom-center":
+      return thumbnails_exports.Layout.alignBottomCenter(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    case "bottom-right":
+      return thumbnails_exports.Layout.alignBottomRight(resizedImageDimensions, containedImageDimensions, wrapperDimensions);
+    default:
+      return { x: 0, y: 0 };
+  }
+}
+function createSharpShape(dimensions, background) {
+  return sharp(
+    {
+      create: getCreateSharpShape(dimensions, background)
+    }
+  );
+}
+function getCreateSharpShape(dimensions, background) {
+  return {
+    width: Math.round(dimensions.w),
+    height: Math.round(dimensions.h),
+    channels: 4,
+    background: { r: background[0], g: background[1], b: background[2], alpha: 1 }
+  };
+}
+function getSharpTilesInputs(tiles, palette) {
+  let usedColorsIndexes = [];
+  const paletteLength = palette.length;
+  const getUnusedColorIndex = () => {
+    const paletteIndex = thumbnails_exports.Common.randomInt(paletteLength);
+    resetUnusedColorIndexesIfNeeded();
+    if (usedColorsIndexes.includes(paletteIndex)) {
+      return getUnusedColorIndex();
+    }
+    usedColorsIndexes.push(paletteIndex);
+    return paletteIndex;
+  };
+  const resetUnusedColorIndexesIfNeeded = () => {
+    if (usedColorsIndexes.length !== paletteLength) {
+      return;
+    }
+    usedColorsIndexes = [];
+  };
+  return tiles.map((tile) => {
+    const paletteIndex = getUnusedColorIndex();
+    const color = palette[paletteIndex];
+    if (!color) {
+      return;
+    }
+    return {
+      top: Math.round(tile.y),
+      left: Math.round(tile.x),
+      input: sharp(
+        {
+          create: getCreateSharpShape(tile, color)
+        }
+      )
+    };
+  }).filter((sharpShape) => sharpShape !== void 0);
+}
+
+export {
+  areaCompose,
+  getSharpTilesInputs
+};