@design-edito/tools 0.1.66 → 0.1.68

package/chunks/chunk-VDT6ODFV.js

@@ -0,0 +1,20 @@
+import {
+  file_exports
+} from "./chunk-WH5V6GK7.js";
+import {
+  bucket_exports
+} from "./chunk-XSVBWVVC.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/@google-cloud/storage/index.ts
+var storage_exports = {};
+__export(storage_exports, {
+  Bucket: () => bucket_exports,
+  File: () => file_exports
+});
+
+export {
+  storage_exports
+};

package/chunks/chunk-VHPX7UA3.js

@@ -0,0 +1,177 @@
+import {
+  frame
+} from "./chunk-JX45LILQ.js";
+import {
+  frameSchema
+} from "./chunk-Y7YEYHRZ.js";
+import {
+  compose
+} from "./chunk-AWVQJNGX.js";
+import {
+  scale
+} from "./chunk-JRYI4VBX.js";
+import {
+  lineateLevelsSchema
+} from "./chunk-KL6EJPC3.js";
+import {
+  normalizeSchema
+} from "./chunk-4QHGUANF.js";
+import {
+  resizeSchema
+} from "./chunk-VR5JHUKK.js";
+import {
+  rotateSchema
+} from "./chunk-X6WCMUOP.js";
+import {
+  scaleSchema
+} from "./chunk-GOTTGEXI.js";
+import {
+  saturateSchema
+} from "./chunk-XQMUFSLU.js";
+import {
+  extractSchema
+} from "./chunk-NA7PT2KE.js";
+import {
+  composeSchema
+} from "./chunk-UUU6DWRQ.js";
+import {
+  flipSchema
+} from "./chunk-7OK5NZTY.js";
+import {
+  flopSchema
+} from "./chunk-B4XUXE7E.js";
+import {
+  flattenSchema
+} from "./chunk-UERX6XGZ.js";
+import {
+  hueRotateSchema
+} from "./chunk-JQRLQUMJ.js";
+import {
+  lightenSchema
+} from "./chunk-HFIE4SBE.js";
+import {
+  modulateSchema
+} from "./chunk-J35QFU6O.js";
+import {
+  blurSchema
+} from "./chunk-U5WEI3QA.js";
+import {
+  brightenSchema
+} from "./chunk-4PJWXOLA.js";
+import {
+  extendSchema
+} from "./chunk-MFK63FMI.js";
+import {
+  esm_default
+} from "./chunk-YE67BQQN.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/images/transform/index.ts
+var transform_exports = {};
+__export(transform_exports, {
+  apply: () => apply,
+  isOperation: () => isOperation,
+  transform: () => transform
+});
+import sharp from "sharp";
+var operationSchema = esm_default.union([
+  // areaComposeSchema,
+  blurSchema,
+  brightenSchema,
+  composeSchema,
+  extendSchema,
+  extractSchema,
+  flattenSchema,
+  flipSchema,
+  flopSchema,
+  frameSchema,
+  hueRotateSchema,
+  lightenSchema,
+  lineateLevelsSchema,
+  modulateSchema,
+  normalizeSchema,
+  resizeSchema,
+  rotateSchema,
+  saturateSchema,
+  scaleSchema
+]);
+function isOperation(operation) {
+  try {
+    return Outcome.makeSuccess(operationSchema.parse(operation));
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+async function transform(imageBuffer, operations, checkValidOperations) {
+  let sharpInstance = sharp(imageBuffer);
+  const needsValidation = checkValidOperations ?? false;
+  for (const operation of operations) {
+    const _isOperation = isOperation(operation);
+    if (!needsValidation || _isOperation.success) {
+      console.log("Images:Transform:Operation:Start", operation.name);
+      sharpInstance = await apply(sharpInstance, operation);
+      console.log("Images:Transform:Operation:Done", operation.name);
+    }
+  }
+  return sharpInstance.toBuffer();
+}
+async function apply(sharpInstance, operation) {
+  switch (operation.name) {
+    case OperationNames.Blur:
+      return sharpInstance.blur(operation.params.sigma);
+    case OperationNames.Brighten:
+      return sharpInstance.blur(operation.params);
+    case OperationNames.Compose:
+      return compose(sharpInstance, operation.params);
+    case OperationNames.Extend:
+      return sharpInstance.extend(operation.params);
+    case OperationNames.Extract:
+      return sharpInstance.extract(operation.params);
+    case OperationNames.Flip:
+      return sharpInstance.flip(operation.params.flip);
+    case OperationNames.Flop:
+      return sharpInstance.flop(operation.params.flop);
+    case OperationNames.Frame:
+      return frame(sharpInstance, operation.params);
+    case OperationNames.Flatten:
+      return sharpInstance.flatten(operation.params);
+    case OperationNames.HueRotate:
+      return sharpInstance.modulate({ hue: operation.params });
+    case OperationNames.Lighten:
+      return sharpInstance.modulate({ lightness: operation.params });
+    case OperationNames.LineateLevels:
+      return sharpInstance.linear(operation.params.multiplier, operation.params.offset);
+    case OperationNames.Modulate:
+      return sharpInstance.modulate(operation.params);
+    case OperationNames.Normalize:
+      return sharpInstance.normalize(operation.params);
+    case OperationNames.Resize:
+      return sharpInstance.resize(operation.params);
+    case OperationNames.Rotate:
+      return sharpInstance.rotate(operation.params.angle);
+    case OperationNames.Saturate:
+      return sharpInstance.modulate({ saturation: operation.params });
+    case OperationNames.Scale:
+      return scale(sharpInstance, operation.params);
+    default:
+      return sharpInstance;
+  }
+}
+
+export {
+  isOperation,
+  transform,
+  apply,
+  transform_exports
+};

package/chunks/chunk-VR5JHUKK.js

@@ -0,0 +1,32 @@
+import {
+  colorSchema
+} from "./chunk-U7R6TPHR.js";
+import {
+  esm_default
+} from "./chunk-YE67BQQN.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.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-VSBRIQPH.js

@@ -0,0 +1,48 @@
+import {
+  download
+} from "./chunk-IARWH6LC.js";
+import {
+  download as download2
+} from "./chunk-26QQ56SS.js";
+import {
+  download as download4
+} from "./chunk-V4S34MIM.js";
+import {
+  s3IdentifierData
+} from "./chunk-MOBGB2PH.js";
+import {
+  download as download3
+} from "./chunk-MFWKY3DT.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/cloud-storage/operations/download/index.ts
+var download_exports = {};
+__export(download_exports, {
+  download: () => download5
+});
+import { Bucket } from "@google-cloud/storage";
+import { S3 } from "aws-sdk";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+async function download5(targetPath, endpointType, endpointIdentifier, client) {
+  if (endpointType === "gcs-bucket" /* GCS */ && client instanceof Bucket) return await download(targetPath, client);
+  if (endpointType === "s3-bucket" /* S3 */ && client instanceof S3) {
+    const { bucketName } = s3IdentifierData(endpointIdentifier);
+    if (bucketName === null) return Outcome.makeFailure("Invalid S3 bucket name");
+    return await download2(targetPath, bucketName, client);
+  }
+  if (endpointType === "ftp" /* FTP */ && client instanceof FtpClient) return await download3(targetPath, client);
+  if (endpointType === "ftps" /* FTPS */ && client instanceof FtpClient) return await download3(targetPath, client);
+  if (endpointType === "sftp" /* SFTP */ && client instanceof SftpClient) return await download4(targetPath, client);
+  return Outcome.makeFailure("Invalid endpoint or client type");
+}
+
+export {
+  download5 as download,
+  download_exports
+};

package/chunks/chunk-WC2LQPQP.js

@@ -0,0 +1,26 @@
+import {
+  Crossenv
+} from "./chunk-UFKH5WD2.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
+  },
+  ["impossible-to-pick-in-array" /* IMPOSSIBLE_TO_PICK_IN_ARRAY */]: {
+    message: "Impossible to pick",
+    detailsMaker: (array) => array.length === 0 ? "Array cannot be empty" : "Too many exclusions"
+  }
+});
+
+export {
+  register
+};

package/chunks/chunk-WH5V6GK7.js

@@ -0,0 +1,56 @@
+import {
+  revoke_signed_urls_exports
+} from "./chunk-UUSZJMJB.js";
+import {
+  get_permissions_exports
+} from "./chunk-GXICX4F6.js";
+import {
+  update_metadata_exports
+} from "./chunk-YW5ASSIQ.js";
+import {
+  copy_exports
+} from "./chunk-SZQHLC4K.js";
+import {
+  generate_signed_url_exports
+} from "./chunk-OPU4CANL.js";
+import {
+  exists_exports
+} from "./chunk-TXGV4KJD.js";
+import {
+  erase_exports
+} from "./chunk-7BCQCDGQ.js";
+import {
+  get_metadata_exports
+} from "./chunk-KFMYB672.js";
+import {
+  move_exports
+} from "./chunk-T55QIYYV.js";
+import {
+  download_exports
+} from "./chunk-IARWH6LC.js";
+import {
+  upload_exports
+} from "./chunk-7FJKDVBE.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/@google-cloud/storage/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Copy: () => copy_exports,
+  Download: () => download_exports,
+  Erase: () => erase_exports,
+  Exists: () => exists_exports,
+  GenerateSignedUrl: () => generate_signed_url_exports,
+  GetMetaData: () => get_metadata_exports,
+  GetPermissions: () => get_permissions_exports,
+  Move: () => move_exports,
+  RevokeSignedUrls: () => revoke_signed_urls_exports,
+  UpdateMetadata: () => update_metadata_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-WIJBRYJ6.js

@@ -0,0 +1,20 @@
+import {
+  download_exports
+} from "./chunk-VSBRIQPH.js";
+import {
+  upload_exports
+} from "./chunk-CHA42BGS.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/cloud-storage/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  Download: () => download_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  operations_exports
+};

package/chunks/chunk-WP7L5ZFP.js

@@ -0,0 +1,173 @@
+import {
+  Random
+} from "./chunk-S32K7POB.js";
+import {
+  register
+} from "./chunk-SJLH36CH.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-WTILPGGX.js

@@ -0,0 +1,69 @@
+import {
+  createTileBackgroundSchema
+} from "./chunk-E3GK7YZ7.js";
+import {
+  createLineBackgroundSchema
+} from "./chunk-YCSC7QNV.js";
+import {
+  positionsSchema
+} from "./chunk-D47ZPEUU.js";
+import {
+  colorSchema
+} from "./chunk-U7R6TPHR.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  esm_default
+} from "./chunk-YE67BQQN.js";
+
+// src/node/images/transform/frame/index.tsx
+var createBackgroundOptionsSchema = {
+  colorPalette: esm_default.optional(esm_default.object({
+    extract: esm_default.optional(esm_default.object({
+      nbColor: esm_default.number()
+    })),
+    use: esm_default.optional(esm_default.object({
+      RGBColors: esm_default.array(esm_default.tuple([esm_default.number(), esm_default.number(), esm_default.number()]))
+    })),
+    densify: esm_default.optional(esm_default.object({
+      types: esm_default.array(esm_default.enum([
+        "default",
+        "default-lighten",
+        "default-saturate",
+        "complementary",
+        "complementary-lighten",
+        "complementary-saturate"
+      ])),
+      ligthenIntensity: esm_default.optional(esm_default.number()),
+      saturateIntensity: esm_default.optional(esm_default.number())
+    })),
+    compose: esm_default.optional(esm_default.object({
+      nbColor: esm_default.optional(esm_default.number()),
+      mix: esm_default.optional(esm_default.boolean())
+    }))
+  }))
+};
+var frameSchema = esm_default.object({
+  name: esm_default.literal(OperationNames.Frame),
+  params: esm_default.object({
+    dimensions: esm_default.object({
+      widthPx: esm_default.number().min(0),
+      heightPx: esm_default.number().min(0)
+    }),
+    imageScale: esm_default.object({
+      xRatio: esm_default.optional(esm_default.number().min(0).max(1)),
+      yRatio: esm_default.optional(esm_default.number().min(0).max(1))
+    }).optional(),
+    positions: positionsSchema,
+    background: esm_default.union([
+      colorSchema,
+      createLineBackgroundSchema.extend(createBackgroundOptionsSchema),
+      createTileBackgroundSchema.extend(createBackgroundOptionsSchema)
+    ])
+  })
+});
+
+export {
+  frameSchema
+};

package/chunks/chunk-X34YXAEL.js

@@ -0,0 +1,31 @@
+import {
+  make
+} from "./chunk-RLAZR3NL.js";
+import {
+  randomPick,
+  randomPickMany
+} from "./chunk-AQBJ6HNB.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.js";
+import {
+  findDuplicates
+} from "./chunk-YS6WMSWC.js";
+import {
+  isArrayOf
+} from "./chunk-6RGDWX4A.js";
+
+// src/agnostic/arrays/index.tsx
+var Arrays;
+((Arrays2) => {
+  Arrays2.findDuplicates = findDuplicates;
+  Arrays2.isArrayOf = isArrayOf;
+  Arrays2.make = make;
+  Arrays2.randomPick = randomPick;
+  Arrays2.randomPickMany = randomPickMany;
+  Arrays2.shuffle = shuffle;
+})(Arrays || (Arrays = {}));
+
+export {
+  Arrays
+};

package/chunks/chunk-X6WCMUOP.js

@@ -0,0 +1,18 @@
+import {
+  esm_default
+} from "./chunk-YE67BQQN.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/rotate/index.ts
+var rotateSchema = esm_default.object({
+  name: esm_default.literal(OperationNames.Rotate),
+  params: esm_default.object({
+    angle: esm_default.number()
+  })
+});
+
+export {
+  rotateSchema
+};