@design-edito/tools 0.1.51 → 0.1.53

package/chunks/chunk-RVVJ4QD4.js

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

@@ -0,0 +1,31 @@
+import {
+  isArrayOf
+} from "./chunk-6RGDWX4A.js";
+import {
+  findDuplicates
+} from "./chunk-YS6WMSWC.js";
+import {
+  make
+} from "./chunk-RLAZR3NL.js";
+import {
+  randomPick,
+  randomPickMany
+} from "./chunk-WJMBLQRX.js";
+import {
+  shuffle
+} from "./chunk-VJJIYJMY.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-TXOUGP37.js

@@ -0,0 +1,62 @@
+import {
+  areaCompose
+} from "./chunk-4LCL2RIC.js";
+import {
+  require_lib
+} from "./chunk-53MBV4TG.js";
+import {
+  __export,
+  __toESM
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/images/transform/index.ts
+var transform_exports = {};
+__export(transform_exports, {
+  isOperation: () => isOperation,
+  transformImage: () => transformImage
+});
+var import_sharp = __toESM(require_lib(), 1);
+async function transformImage(imageBuffer, operations, maxDimensions) {
+  const imageSharp = (0, import_sharp.default)(imageBuffer);
+  let imageSharped = imageSharp;
+  for await (const operation of operations) {
+    if (isOperation(operation)) {
+      imageSharped = await applyOperation(imageSharped, operation, maxDimensions);
+    }
+  }
+  return await imageSharped.toBuffer();
+}
+function isOperation(operation) {
+  return true;
+}
+async function applyOperation(imageSharp, operation, maxDimensions) {
+  switch (operation.name) {
+    case "rotate":
+      return imageSharp.rotate(operation.params.angle);
+    case "resize":
+      return imageSharp.resize({
+        width: operation.params.width,
+        height: operation.params.height,
+        fit: operation.params.fit || "cover",
+        background: { r: 255, g: 255, b: 255, alpha: 0 }
+      });
+    /* Adds a transparent background (necessary for png) */
+    case "area-composition":
+      const composedImage = await areaCompose(imageSharp, {
+        ...operation.params,
+        dimensions: {
+          w: maxDimensions.width,
+          h: maxDimensions.height
+        }
+      });
+      return composedImage;
+    default:
+      return imageSharp;
+  }
+}
+
+export {
+  transformImage,
+  isOperation,
+  transform_exports
+};

package/chunks/chunk-UG36UPJK.js

@@ -0,0 +1,31 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/@google-cloud/storage/file/update-metadata/index.ts
+var update_metadata_exports = {};
+__export(update_metadata_exports, {
+  updateFileMetadata: () => updateFileMetadata
+});
+async function updateFileMetadata(sourcePath, bucket, metadata, options) {
+  const { fileOptions, metadataOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    await file.setMetadata(metadata, metadataOptions);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  updateFileMetadata,
+  update_metadata_exports
+};

package/chunks/chunk-UXM54YBI.js

@@ -0,0 +1,68 @@
+import {
+  __export
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/@design-edito/thumbnails/easings/index.ts
+var easings_exports = {};
+__export(easings_exports, {
+  ease: () => ease,
+  easeInOutQuad: () => easeInOutQuad,
+  easeInOutSine: () => easeInOutSine,
+  easeInQuad: () => easeInQuad,
+  easeInSine: () => easeInSine,
+  easeOutQuad: () => easeOutQuad,
+  easeOutSine: () => easeOutSine,
+  linear: () => linear
+});
+function ease(t, name) {
+  switch (name) {
+    case "in-sine":
+      return easeInSine(t);
+    case "out-sine":
+      return easeOutSine(t);
+    case "in-out-sine":
+      return easeInOutSine(t);
+    case "in-quad":
+      return easeInQuad(t);
+    case "out-quad":
+      return easeOutQuad(t);
+    case "in-out-quad":
+      return easeInOutQuad(t);
+    case "linear":
+    default:
+      return linear(t);
+  }
+}
+function linear(t) {
+  return t;
+}
+function easeOutSine(t) {
+  return Math.sin(t * (Math.PI / 2));
+}
+function easeInSine(t) {
+  return -1 * Math.cos(t * (Math.PI / 2)) + 1;
+}
+function easeInOutSine(t) {
+  return -0.5 * (Math.cos(Math.PI * t) - 1);
+}
+function easeInQuad(t) {
+  return t * t;
+}
+function easeOutQuad(t) {
+  return t * (2 - t);
+}
+function easeInOutQuad(t) {
+  return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+}
+
+export {
+  ease,
+  linear,
+  easeOutSine,
+  easeInSine,
+  easeInOutSine,
+  easeInQuad,
+  easeOutQuad,
+  easeInOutQuad,
+  easings_exports
+};

package/chunks/chunk-VHFMQI7Z.js

@@ -0,0 +1,20 @@
+import {
+  get_metadata_exports
+} from "./chunk-AF2MI5O5.js";
+import {
+  list_exports
+} from "./chunk-KYMCGWPM.js";
+import {
+  __export
+} from "./chunk-XCBH6NLF.js";
+
+// src/node/@google-cloud/storage/bucket/index.ts
+var bucket_exports = {};
+__export(bucket_exports, {
+  GetMetadata: () => get_metadata_exports,
+  List: () => list_exports
+});
+
+export {
+  bucket_exports
+};

package/chunks/chunk-VP3Y6EMX.js

@@ -0,0 +1,190 @@
+import {
+  __commonJS,
+  __require
+} from "./chunk-XCBH6NLF.js";
+
+// node_modules/inherits/inherits_browser.js
+var require_inherits_browser = __commonJS({
+  "node_modules/inherits/inherits_browser.js"(exports, module) {
+    if (typeof Object.create === "function") {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          ctor.prototype = Object.create(superCtor.prototype, {
+            constructor: {
+              value: ctor,
+              enumerable: false,
+              writable: true,
+              configurable: true
+            }
+          });
+        }
+      };
+    } else {
+      module.exports = function inherits(ctor, superCtor) {
+        if (superCtor) {
+          ctor.super_ = superCtor;
+          var TempCtor = function() {
+          };
+          TempCtor.prototype = superCtor.prototype;
+          ctor.prototype = new TempCtor();
+          ctor.prototype.constructor = ctor;
+        }
+      };
+    }
+  }
+});
+
+// node_modules/inherits/inherits.js
+var require_inherits = __commonJS({
+  "node_modules/inherits/inherits.js"(exports, module) {
+    try {
+      util = __require("util");
+      if (typeof util.inherits !== "function") throw "";
+      module.exports = util.inherits;
+    } catch (e) {
+      module.exports = require_inherits_browser();
+    }
+    var util;
+  }
+});
+
+// node_modules/process-nextick-args/index.js
+var require_process_nextick_args = __commonJS({
+  "node_modules/process-nextick-args/index.js"(exports, module) {
+    "use strict";
+    if (typeof process === "undefined" || !process.version || process.version.indexOf("v0.") === 0 || process.version.indexOf("v1.") === 0 && process.version.indexOf("v1.8.") !== 0) {
+      module.exports = { nextTick };
+    } else {
+      module.exports = process;
+    }
+    function nextTick(fn, arg1, arg2, arg3) {
+      if (typeof fn !== "function") {
+        throw new TypeError('"callback" argument must be a function');
+      }
+      var len = arguments.length;
+      var args, i;
+      switch (len) {
+        case 0:
+        case 1:
+          return process.nextTick(fn);
+        case 2:
+          return process.nextTick(function afterTickOne() {
+            fn.call(null, arg1);
+          });
+        case 3:
+          return process.nextTick(function afterTickTwo() {
+            fn.call(null, arg1, arg2);
+          });
+        case 4:
+          return process.nextTick(function afterTickThree() {
+            fn.call(null, arg1, arg2, arg3);
+          });
+        default:
+          args = new Array(len - 1);
+          i = 0;
+          while (i < args.length) {
+            args[i++] = arguments[i];
+          }
+          return process.nextTick(function afterTick() {
+            fn.apply(null, args);
+          });
+      }
+    }
+  }
+});
+
+// node_modules/isarray/index.js
+var require_isarray = __commonJS({
+  "node_modules/isarray/index.js"(exports, module) {
+    var toString = {}.toString;
+    module.exports = Array.isArray || function(arr) {
+      return toString.call(arr) == "[object Array]";
+    };
+  }
+});
+
+// node_modules/core-util-is/lib/util.js
+var require_util = __commonJS({
+  "node_modules/core-util-is/lib/util.js"(exports) {
+    function isArray(arg) {
+      if (Array.isArray) {
+        return Array.isArray(arg);
+      }
+      return objectToString(arg) === "[object Array]";
+    }
+    exports.isArray = isArray;
+    function isBoolean(arg) {
+      return typeof arg === "boolean";
+    }
+    exports.isBoolean = isBoolean;
+    function isNull(arg) {
+      return arg === null;
+    }
+    exports.isNull = isNull;
+    function isNullOrUndefined(arg) {
+      return arg == null;
+    }
+    exports.isNullOrUndefined = isNullOrUndefined;
+    function isNumber(arg) {
+      return typeof arg === "number";
+    }
+    exports.isNumber = isNumber;
+    function isString(arg) {
+      return typeof arg === "string";
+    }
+    exports.isString = isString;
+    function isSymbol(arg) {
+      return typeof arg === "symbol";
+    }
+    exports.isSymbol = isSymbol;
+    function isUndefined(arg) {
+      return arg === void 0;
+    }
+    exports.isUndefined = isUndefined;
+    function isRegExp(re) {
+      return objectToString(re) === "[object RegExp]";
+    }
+    exports.isRegExp = isRegExp;
+    function isObject(arg) {
+      return typeof arg === "object" && arg !== null;
+    }
+    exports.isObject = isObject;
+    function isDate(d) {
+      return objectToString(d) === "[object Date]";
+    }
+    exports.isDate = isDate;
+    function isError(e) {
+      return objectToString(e) === "[object Error]" || e instanceof Error;
+    }
+    exports.isError = isError;
+    function isFunction(arg) {
+      return typeof arg === "function";
+    }
+    exports.isFunction = isFunction;
+    function isPrimitive(arg) {
+      return arg === null || typeof arg === "boolean" || typeof arg === "number" || typeof arg === "string" || typeof arg === "symbol" || // ES6 symbol
+      typeof arg === "undefined";
+    }
+    exports.isPrimitive = isPrimitive;
+    exports.isBuffer = __require("buffer").Buffer.isBuffer;
+    function objectToString(o) {
+      return Object.prototype.toString.call(o);
+    }
+  }
+});
+
+// node_modules/util-deprecate/node.js
+var require_node = __commonJS({
+  "node_modules/util-deprecate/node.js"(exports, module) {
+    module.exports = __require("util").deprecate;
+  }
+});
+
+export {
+  require_process_nextick_args,
+  require_isarray,
+  require_util,
+  require_inherits,
+  require_node
+};