@design-edito/tools 0.2.0 → 0.2.1

package/chunks/chunk-R765J7H2.js

@@ -0,0 +1,114 @@
+import {
+  zod_default
+} from "./chunk-OT4SVHDX.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/images/format/index.ts
+var format_exports = {};
+__export(format_exports, {
+  format: () => format,
+  isFormatAvifOptions: () => isFormatAvifOptions,
+  isFormatCommonOptions: () => isFormatCommonOptions,
+  isFormatHeifOptions: () => isFormatHeifOptions,
+  isFormatJpgOptions: () => isFormatJpgOptions,
+  isFormatKeepOptions: () => isFormatKeepOptions,
+  isFormatOptions: () => isFormatOptions,
+  isFormatPngOptions: () => isFormatPngOptions,
+  isFormatTiffOptions: () => isFormatTiffOptions,
+  isFormatWebpOptions: () => isFormatWebpOptions,
+  toAvif: () => toAvif,
+  toHeif: () => toHeif,
+  toHeight: () => toHeight,
+  toJpg: () => toJpg,
+  toPng: () => toPng,
+  toTiff: () => toTiff,
+  toWebp: () => toWebp,
+  toWidth: () => toWidth
+});
+import sharp from "sharp";
+var formatCommonOptionsSchema = zod_default.object({
+  width: zod_default.number().optional(),
+  height: zod_default.number().optional(),
+  fit: zod_default.enum(["contain", "cover", "fill", "inside", "outside"]).optional()
+});
+var formatJpgOptionsSchema = formatCommonOptionsSchema.extend({ quality: zod_default.number().optional() });
+var formatPngOptionsSchema = formatCommonOptionsSchema.extend({
+  quality: zod_default.number().optional(),
+  compressionLevel: zod_default.number().optional()
+});
+var formatWebpOptionsSchema = formatCommonOptionsSchema.extend({ quality: zod_default.number().optional() });
+var formatAvifOptionsSchema = formatCommonOptionsSchema.extend({ quality: zod_default.number().optional() });
+var formatTiffOptionsSchema = formatCommonOptionsSchema.extend({
+  quality: zod_default.number().optional(),
+  compression: zod_default.enum(["none", "jpeg", "deflate", "packbits", "ccittfax4", "lzw", "webp", "zstd", "jp2k"]).optional()
+});
+var formatHeifOptionsSchema = formatCommonOptionsSchema.extend({ quality: zod_default.number().optional() });
+var formatKeepOptionsSchema = formatCommonOptionsSchema;
+var formatOptionsSchema = zod_default.union([
+  formatJpgOptionsSchema,
+  formatPngOptionsSchema,
+  formatWebpOptionsSchema,
+  formatAvifOptionsSchema,
+  formatTiffOptionsSchema,
+  formatHeifOptionsSchema,
+  formatKeepOptionsSchema
+]);
+var isFormatCommonOptions = (options) => formatCommonOptionsSchema.safeParse(options).success;
+var isFormatJpgOptions = (options) => formatJpgOptionsSchema.safeParse(options).success;
+var isFormatPngOptions = (options) => formatPngOptionsSchema.safeParse(options).success;
+var isFormatWebpOptions = (options) => formatWebpOptionsSchema.safeParse(options).success;
+var isFormatAvifOptions = (options) => formatAvifOptionsSchema.safeParse(options).success;
+var isFormatTiffOptions = (options) => formatTiffOptionsSchema.safeParse(options).success;
+var isFormatHeifOptions = (options) => formatHeifOptionsSchema.safeParse(options).success;
+var isFormatKeepOptions = (options) => formatKeepOptionsSchema.safeParse(options).success;
+var isFormatOptions = (options) => formatOptionsSchema.safeParse(options).success;
+async function format(input, typeOrOptions, options) {
+  const sharpInstance = sharp(input);
+  if (typeof typeOrOptions !== "string") return Outcome.makeSuccess(await sharpInstance.resize(typeOrOptions).toBuffer());
+  const type = typeOrOptions;
+  if (type === "jpg" || type === "jpeg") return Outcome.makeSuccess(await sharpInstance.jpeg(options).toBuffer());
+  if (type === "png") return Outcome.makeSuccess(await sharpInstance.png(options).toBuffer());
+  if (type === "webp") return Outcome.makeSuccess(await sharpInstance.webp(options).toBuffer());
+  if (type === "avif") return Outcome.makeSuccess(await sharpInstance.avif(options).toBuffer());
+  if (type === "tiff") return Outcome.makeSuccess(await sharpInstance.tiff(options).toBuffer());
+  if (type === "heif") return Outcome.makeSuccess(await sharpInstance.heif(options).toBuffer());
+  return Outcome.makeFailure(`Invalid image format: ${type}`);
+}
+var toWidth = async (input, width) => sharp(input).resize({ width }).toBuffer();
+var toHeight = async (input, height) => sharp(input).resize({ height }).toBuffer();
+var toJpg = async (input, quality) => sharp(input).jpeg({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toPng = async (input, quality, compressionLevel) => sharp(input).png({ quality: clamp(quality ?? 100, 1, 100), compressionLevel }).toBuffer();
+var toWebp = async (input, quality) => sharp(input).webp({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toAvif = async (input, quality) => sharp(input).avif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+var toTiff = async (input, quality, compression) => sharp(input).tiff({ quality: clamp(quality ?? 100, 1, 100), compression }).toBuffer();
+var toHeif = async (input, quality) => sharp(input).heif({ quality: clamp(quality ?? 100, 1, 100) }).toBuffer();
+
+export {
+  isFormatCommonOptions,
+  isFormatJpgOptions,
+  isFormatPngOptions,
+  isFormatWebpOptions,
+  isFormatAvifOptions,
+  isFormatTiffOptions,
+  isFormatHeifOptions,
+  isFormatKeepOptions,
+  isFormatOptions,
+  format,
+  toWidth,
+  toHeight,
+  toJpg,
+  toPng,
+  toWebp,
+  toAvif,
+  toTiff,
+  toHeif,
+  format_exports
+};

package/chunks/chunk-S6S6O3VI.js

@@ -0,0 +1,168 @@
+import {
+  flatten,
+  isFlattenOperationParams
+} from "./chunk-VTDLFWOD.js";
+import {
+  isLightenOperationParams,
+  lighten
+} from "./chunk-2FC5KUMS.js";
+import {
+  isLevelOperationParams,
+  level
+} from "./chunk-T3D55RRI.js";
+import {
+  isNormalizeOperationParams,
+  normalize
+} from "./chunk-7NOLNBF6.js";
+import {
+  isResizeOperationParams,
+  resize
+} from "./chunk-FORJXSIW.js";
+import {
+  isRotateOperationParams,
+  rotate
+} from "./chunk-KZKHIPWQ.js";
+import {
+  isSaturateOperationParams,
+  saturate
+} from "./chunk-UPSIFUMS.js";
+import {
+  brighten,
+  isBrightenOperationParams
+} from "./chunk-YTGB73UX.js";
+import {
+  blur,
+  isBlurOperationParams
+} from "./chunk-PJFSPYPO.js";
+import {
+  extend,
+  isExtendOperationParams
+} from "./chunk-MMGAJ7EW.js";
+import {
+  extract,
+  isExtractOperationParams
+} from "./chunk-5JX7EWIW.js";
+import {
+  flip
+} from "./chunk-WNDMYNDU.js";
+import {
+  hue,
+  isHueOperationParams
+} from "./chunk-3YW3KBO5.js";
+import {
+  flop
+} from "./chunk-YA2YCZUF.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-T3D55RRI.js

@@ -0,0 +1,22 @@
+import {
+  zod_default
+} from "./chunk-OT4SVHDX.js";
+
+// src/node/images/transform/operations/level/index.ts
+function isLevelOperationParams(obj) {
+  return zod_default.object({
+    multiplier: zod_default.number().optional(),
+    offset: zod_default.number().optional()
+  }).safeParse(obj).success;
+}
+async function level(sharpInstance, params) {
+  return sharpInstance.linear(
+    params.multiplier,
+    params.offset
+  );
+}
+
+export {
+  isLevelOperationParams,
+  level
+};

package/chunks/chunk-UFKH5WD2.js

@@ -0,0 +1,21 @@
+import {
+  Window
+} from "./chunk-RLJOYG64.js";
+import {
+  detectRuntime
+} from "./chunk-S2NMAH7K.js";
+import {
+  Types
+} from "./chunk-LV2VMOWR.js";
+
+// src/agnostic/misc/crossenv/index.ts
+var Crossenv;
+((Crossenv2) => {
+  Crossenv2.detectRuntime = detectRuntime;
+  Crossenv2.Types = Types;
+  Crossenv2.Window = Window;
+})(Crossenv || (Crossenv = {}));
+
+export {
+  Crossenv
+};

package/chunks/chunk-UODICVLG.js

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

@@ -0,0 +1,18 @@
+import {
+  zod_default
+} from "./chunk-OT4SVHDX.js";
+
+// src/node/images/transform/operations/saturate/index.ts
+function isSaturateOperationParams(obj) {
+  return zod_default.object({
+    saturation: zod_default.number().optional()
+  }).safeParse(obj).success;
+}
+async function saturate(sharpInstance, params) {
+  return sharpInstance.modulate({ saturation: params.saturation });
+}
+
+export {
+  isSaturateOperationParams,
+  saturate
+};