@design-edito/tools 0.3.16 → 0.3.17

package/chunks/chunk-UVG2S54P.js

@@ -0,0 +1,93 @@
+import {
+  resizeObserver
+} from "./chunk-3DNVFA25.js";
+import {
+  clss
+} from "./chunk-TRFZSKNB.js";
+import {
+  mergeClassNames
+} from "./chunk-OFCSIK6J.js";
+
+// src/components/ResizeObserver/index.tsx
+import {
+  useRef,
+  useEffect,
+  useState
+} from "react";
+
+// src/components/ResizeObserver/style.module.css
+var style_default = {};
+
+// src/components/ResizeObserver/index.tsx
+import { jsx } from "react/jsx-runtime";
+var ResizeObserverComponent = ({
+  className,
+  onResized,
+  children
+}) => {
+  const [roEntry, setRoEntry] = useState();
+  const rootRef = useRef(null);
+  const observerRef = useRef(null);
+  const createObserver = () => {
+    const root = rootRef.current;
+    observerRef.current?.disconnect();
+    if (root === null) return;
+    observerRef.current = new ResizeObserver((entries) => {
+      const firstEntry = entries[0];
+      if (firstEntry !== void 0) {
+        const boundingClientRect = firstEntry.target.getBoundingClientRect();
+        const fullEntry = {
+          entry: firstEntry,
+          boundingClientRect
+        };
+        setRoEntry(fullEntry);
+        if (onResized === void 0) return;
+        onResized(fullEntry);
+      }
+    });
+    observerRef.current.observe(root);
+  };
+  useEffect(() => {
+    createObserver();
+    return () => observerRef.current?.disconnect();
+  }, [onResized]);
+  const {
+    x,
+    y,
+    top,
+    left,
+    bottom,
+    right,
+    width,
+    height
+  } = roEntry?.entry.contentRect ?? {};
+  const contentRect = { x, y, top, left, bottom, right, width, height };
+  const dataAttributes = Object.entries(contentRect).reduce((acc, [key, val]) => {
+    if (val === void 0) return acc;
+    return { ...acc, [`data-${key}`]: val.toString() };
+  }, {});
+  const cssCustomProps = Object.entries(contentRect).reduce((acc, [key, val]) => {
+    if (val === void 0) return acc;
+    return {
+      ...acc,
+      [`--${resizeObserver}-${key}`]: val.toString(),
+      [`--${resizeObserver}-${key}-px`]: `${val.toString()}px`
+    };
+  }, {});
+  const c = clss(resizeObserver, { cssModule: style_default });
+  const rootClss = mergeClassNames(c(null), className);
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      ...dataAttributes,
+      className: rootClss,
+      ref: rootRef,
+      style: { ...cssCustomProps },
+      children
+    }
+  );
+};
+
+export {
+  ResizeObserverComponent
+};

package/chunks/chunk-VPBZS3S4.js

@@ -0,0 +1,27 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+
+// src/node/images/transform/operations/level/index.ts
+import z from "zod";
+function isLevelOperationParams(obj) {
+  const schema = z.object({
+    multiplier: z.number().optional(),
+    offset: z.number().optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function level(sharpInstance, params) {
+  return sharpInstance.linear(
+    params.multiplier,
+    params.offset
+  );
+}
+
+export {
+  isLevelOperationParams,
+  level
+};

package/chunks/chunk-W5A2TON3.js

@@ -0,0 +1,10 @@
+// src/agnostic/css/is-valid-css-class-name/index.ts
+var classNameRegex = /^-?[_a-zA-Z]+[_a-zA-Z0-9-]*$/;
+function isValidClassName(string) {
+  return classNameRegex.test(string);
+}
+
+export {
+  classNameRegex,
+  isValidClassName
+};

package/chunks/chunk-W7PJ5NQQ.js

@@ -0,0 +1,23 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+
+// src/node/images/transform/operations/lighten/index.ts
+import z from "zod";
+function isLightenOperationParams(obj) {
+  const schema = z.object({
+    amount: z.number().optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function lighten(sharpInstance, params) {
+  return sharpInstance.modulate({ lightness: params.amount });
+}
+
+export {
+  isLightenOperationParams,
+  lighten
+};

package/chunks/chunk-WGRQXVBK.js

@@ -0,0 +1,207 @@
+import {
+  toCmyk,
+  toHsb,
+  toHsl,
+  toLab,
+  toLch,
+  toRgb,
+  toXyz,
+  viaCmyk,
+  viaHsb,
+  viaHsl,
+  viaLab,
+  viaLch,
+  viaRgb,
+  viaXyz
+} from "./chunk-CVMYA5XK.js";
+import {
+  absoluteModulo
+} from "./chunk-DNIOWD7K.js";
+import {
+  clamp
+} from "./chunk-OSAXBA7G.js";
+
+// src/agnostic/colors/channels/index.ts
+function setChannel(color, channel, value) {
+  switch (channel) {
+    case "red":
+      return viaRgb(color, (rgb) => ({ ...rgb, r: clamp(value, 0, 255) }));
+    case "green":
+      return viaRgb(color, (rgb) => ({ ...rgb, g: clamp(value, 0, 255) }));
+    case "blue":
+      return viaRgb(color, (rgb) => ({ ...rgb, b: clamp(value, 0, 255) }));
+    case "hue":
+      return viaHsl(color, (hsl) => ({ ...hsl, h: absoluteModulo(value, 360) }));
+    case "saturation":
+      return viaHsl(color, (hsl) => ({ ...hsl, s: clamp(value, 0, 100) }));
+    case "lightness":
+      return viaHsl(color, (hsl) => ({ ...hsl, l: clamp(value, 0, 100) }));
+    case "brightness":
+      return viaHsb(color, (hsb) => ({ ...hsb, b: clamp(value, 0, 100) }));
+    case "alpha":
+      return viaRgb(color, (rgb) => ({ ...rgb, a: clamp(value, 0, 1) }));
+    case "cyan":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, c: clamp(value, 0, 100) }));
+    case "magenta":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, m: clamp(value, 0, 100) }));
+    case "yellow":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, y: clamp(value, 0, 100) }));
+    case "black":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, k: clamp(value, 0, 100) }));
+    case "x":
+      return viaXyz(color, (xyz) => ({ ...xyz, x: value }));
+    case "y":
+      return viaXyz(color, (xyz) => ({ ...xyz, y: value }));
+    case "z":
+      return viaXyz(color, (xyz) => ({ ...xyz, z: value }));
+    case "lightnessLab":
+      return viaLab(color, (lab) => ({ ...lab, a: clamp(value, 0, 100) }));
+    case "aLab":
+      return viaLab(color, (lab) => ({ ...lab, a: value }));
+    case "bLab":
+      return viaLab(color, (lab) => ({ ...lab, b: value }));
+    case "chroma":
+      return viaLch(color, (lch) => ({ ...lch, c: Math.max(0, value) }));
+    case "hueLch":
+      return viaLch(color, (lch) => ({ ...lch, h: clamp(value, 0, 360) }));
+  }
+}
+function getChannel(color, channel) {
+  switch (channel) {
+    case "red":
+      return toRgb(color).r;
+    case "green":
+      return toRgb(color).g;
+    case "blue":
+      return toRgb(color).b;
+    case "hue":
+      return toHsl(color).h;
+    case "saturation":
+      return toHsl(color).s;
+    case "lightness":
+      return toHsl(color).l;
+    case "brightness":
+      return toHsb(color).b;
+    case "alpha":
+      return toRgb(color).a ?? 1;
+    case "cyan":
+      return toCmyk(color).c;
+    case "magenta":
+      return toCmyk(color).m;
+    case "yellow":
+      return toCmyk(color).y;
+    case "black":
+      return toCmyk(color).k;
+    case "x":
+      return toXyz(color).x;
+    case "y":
+      return toXyz(color).y;
+    case "z":
+      return toXyz(color).z;
+    case "lightnessLab":
+      return toLab(color).l;
+    case "aLab":
+      return toLab(color).a;
+    case "bLab":
+      return toLab(color).b;
+    case "chroma":
+      return toLch(color).c;
+    case "hueLch":
+      return toLch(color).h;
+  }
+}
+function addChannel(color, channel, amount) {
+  switch (channel) {
+    case "red":
+      return viaRgb(color, (rgb) => ({ ...rgb, r: clamp(rgb.r + amount, 0, 255) }));
+    case "green":
+      return viaRgb(color, (rgb) => ({ ...rgb, g: clamp(rgb.g + amount, 0, 255) }));
+    case "blue":
+      return viaRgb(color, (rgb) => ({ ...rgb, b: clamp(rgb.b + amount, 0, 255) }));
+    case "hue":
+      return viaHsl(color, (hsl) => ({ ...hsl, h: absoluteModulo(hsl.h + amount, 360) }));
+    case "saturation":
+      return viaHsl(color, (hsl) => ({ ...hsl, s: clamp(hsl.s + amount, 0, 100) }));
+    case "lightness":
+      return viaHsl(color, (hsl) => ({ ...hsl, l: clamp(hsl.l + amount, 0, 100) }));
+    case "brightness":
+      return viaHsb(color, (hsb) => ({ ...hsb, b: clamp(hsb.b + amount, 0, 100) }));
+    case "alpha":
+      return viaRgb(color, (rgb) => ({ ...rgb, a: clamp(rgb.a ?? 1 + amount, 0, 1) }));
+    case "cyan":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, c: clamp(cmyk.c + amount, 0, 100) }));
+    case "magenta":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, m: clamp(cmyk.m + amount, 0, 100) }));
+    case "yellow":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, y: clamp(cmyk.y + amount, 0, 100) }));
+    case "black":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, k: clamp(cmyk.k + amount, 0, 100) }));
+    case "x":
+      return viaXyz(color, (xyz) => ({ ...xyz, x: xyz.x + amount }));
+    case "y":
+      return viaXyz(color, (xyz) => ({ ...xyz, y: xyz.y + amount }));
+    case "z":
+      return viaXyz(color, (xyz) => ({ ...xyz, z: xyz.z + amount }));
+    case "lightnessLab":
+      return viaLab(color, (lab) => ({ ...lab, l: clamp(lab.l + amount, 0, 100) }));
+    case "aLab":
+      return viaLab(color, (lab) => ({ ...lab, a: lab.a + amount }));
+    case "bLab":
+      return viaLab(color, (lab) => ({ ...lab, b: lab.b + amount }));
+    case "chroma":
+      return viaLch(color, (lch) => ({ ...lch, c: Math.max(0, lch.c + amount) }));
+    case "hueLch":
+      return viaLch(color, (lch) => ({ ...lch, h: clamp(lch.h + amount, 0, 360) }));
+  }
+}
+function multChannel(color, channel, factor) {
+  switch (channel) {
+    case "red":
+      return viaRgb(color, (rgb) => ({ ...rgb, r: clamp(rgb.r * factor, 0, 255) }));
+    case "green":
+      return viaRgb(color, (rgb) => ({ ...rgb, g: clamp(rgb.g * factor, 0, 255) }));
+    case "blue":
+      return viaRgb(color, (rgb) => ({ ...rgb, b: clamp(rgb.b * factor, 0, 255) }));
+    case "hue":
+      return viaHsl(color, (hsl) => ({ ...hsl, h: absoluteModulo(hsl.h * factor, 360) }));
+    case "saturation":
+      return viaHsl(color, (hsl) => ({ ...hsl, s: clamp(hsl.s * factor, 0, 100) }));
+    case "lightness":
+      return viaHsl(color, (hsl) => ({ ...hsl, l: clamp(hsl.l * factor, 0, 100) }));
+    case "brightness":
+      return viaHsb(color, (hsb) => ({ ...hsb, b: clamp(hsb.b * factor, 0, 100) }));
+    case "alpha":
+      return viaRgb(color, (rgb) => ({ ...rgb, a: clamp(rgb.a ?? 1 * factor, 0, 1) }));
+    case "cyan":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, c: clamp(cmyk.c * factor, 0, 100) }));
+    case "magenta":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, m: clamp(cmyk.m * factor, 0, 100) }));
+    case "yellow":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, y: clamp(cmyk.y * factor, 0, 100) }));
+    case "black":
+      return viaCmyk(color, (cmyk) => ({ ...cmyk, k: clamp(cmyk.k * factor, 0, 100) }));
+    case "x":
+      return viaXyz(color, (xyz) => ({ ...xyz, x: xyz.x * factor }));
+    case "y":
+      return viaXyz(color, (xyz) => ({ ...xyz, y: xyz.y * factor }));
+    case "z":
+      return viaXyz(color, (xyz) => ({ ...xyz, z: xyz.z * factor }));
+    case "lightnessLab":
+      return viaLab(color, (lab) => ({ ...lab, l: clamp(lab.l * factor, 0, 100) }));
+    case "aLab":
+      return viaLab(color, (lab) => ({ ...lab, a: lab.a * factor }));
+    case "bLab":
+      return viaLab(color, (lab) => ({ ...lab, b: lab.b * factor }));
+    case "chroma":
+      return viaLch(color, (lch) => ({ ...lch, c: Math.max(0, lch.c * factor) }));
+    case "hueLch":
+      return viaLch(color, (lch) => ({ ...lch, h: clamp(lch.h * factor, 0, 360) }));
+  }
+}
+
+export {
+  setChannel,
+  getChannel,
+  addChannel,
+  multChannel
+};

package/chunks/chunk-WIFHP4X7.js

@@ -0,0 +1,56 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@aws-s3/storage/file/upload/index.ts
+import {
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+async function upload(s3, bucketName, targetPath, fileStream, options) {
+  const {
+    uploadSettings,
+    fileMetadata,
+    overwrite = false
+  } = options ?? {};
+  if (!overwrite) {
+    try {
+      const headCommand = new HeadObjectCommand({
+        Bucket: bucketName,
+        Key: targetPath
+      });
+      await s3.send(headCommand);
+      return makeFailure(`File already exists at ${targetPath}.`);
+    } catch (err) {
+      const code = err?.name ?? err?.$metadata?.httpStatusCode;
+      if (code !== "NotFound" && code !== 404) {
+        return makeFailure(unknownToString(err));
+      }
+    }
+  }
+  const params = {
+    ...fileMetadata,
+    Bucket: bucketName,
+    Key: targetPath,
+    Body: fileStream
+  };
+  try {
+    const upload2 = new Upload({
+      client: s3,
+      params,
+      ...uploadSettings
+    });
+    await upload2.done();
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  upload
+};

package/chunks/chunk-WL4WNJ2Y.js

@@ -0,0 +1,39 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/ftps/file/move/index.ts
+async function move(ftpClient, sourcePath, targetPath, options) {
+  const {
+    ensureDir = true,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      await ftpClient.ensureDir(dirPath);
+    }
+    if (!overwrite) {
+      try {
+        await ftpClient.size(targetPath);
+        return makeFailure(`File already exists at ${targetPath}.`);
+      } catch (err) {
+        if (err.code !== 550) {
+          return makeFailure(unknownToString(err));
+        }
+      }
+    }
+    await ftpClient.rename(sourcePath, targetPath);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  move
+};

package/chunks/chunk-WNDMYNDU.js

@@ -0,0 +1,8 @@
+// src/node/images/transform/operations/flip/index.ts
+async function flip(sharpInstance) {
+  return sharpInstance.flip();
+}
+
+export {
+  flip
+};

package/chunks/chunk-WSFCRVEQ.js

@@ -0,0 +1,9 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+export {
+  __export
+};

package/chunks/chunk-WZS4Q3G3.js

@@ -0,0 +1,36 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/directory/copy-dir/index.ts
+async function copyDir(bucket, sourceDir, targetDir, options) {
+  const { getFileOptions, copyOptions, overwrite = false } = options ?? {};
+  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
+  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  try {
+    const [files] = await bucket.getFiles({ ...getFileOptions, prefix: from });
+    for (const f of files) {
+      const rel = f.name.substring(from.length);
+      const dest = `${to}${rel}`;
+      if (!overwrite) {
+        const destFile = bucket.file(dest);
+        const [exists] = await destFile.exists();
+        if (exists) {
+          continue;
+        }
+      }
+      await f.copy(dest, copyOptions);
+    }
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copyDir
+};

package/chunks/chunk-XA4HVHJ4.js

@@ -0,0 +1,18 @@
+// src/agnostic/html/insert-node/index.ts
+function insertNode(node, position, reference) {
+  if (position === "after") {
+    if (reference.nextSibling !== null) reference.parentNode?.insertBefore(node, reference.nextSibling);
+    else reference.parentNode?.appendChild(node);
+  } else if (position === "before") {
+    reference.parentNode?.insertBefore(node, reference);
+  } else if (position === "startof") {
+    if (reference.firstChild !== null) reference.insertBefore(node, reference.firstChild);
+    else reference.appendChild(node);
+  } else {
+    reference.appendChild(node);
+  }
+}
+
+export {
+  insertNode
+};

package/chunks/chunk-XEQ2PBT2.js

@@ -0,0 +1,20 @@
+// src/agnostic/html/hyper-json/types/index.ts
+var Types;
+((Types2) => {
+  let Tree;
+  ((Tree2) => {
+    let Merge;
+    ((Merge2) => {
+      let Action;
+      ((Action2) => {
+        Action2["APPEND"] = "append";
+        Action2["PREPEND"] = "prepend";
+        Action2["REPLACE"] = "replace";
+      })(Action = Merge2.Action || (Merge2.Action = {}));
+    })(Merge = Tree2.Merge || (Tree2.Merge = {}));
+  })(Tree = Types2.Tree || (Types2.Tree = {}));
+})(Types || (Types = {}));
+
+export {
+  Types
+};

package/chunks/chunk-XIIJYVJZ.js

@@ -0,0 +1,15 @@
+// src/agnostic/misc/crossenv/types.ts
+var RuntimeName = /* @__PURE__ */ ((RuntimeName2) => {
+  RuntimeName2["NODE"] = "Node.js";
+  RuntimeName2["BROWSER"] = "Browser";
+  RuntimeName2["DENO"] = "Deno";
+  RuntimeName2["REACT_NATIVE"] = "React Native";
+  RuntimeName2["ELECTRON"] = "Electron";
+  RuntimeName2["CLOUDFLARE"] = "Cloudflare Workers";
+  RuntimeName2["AWS_LAMBDA"] = "AWS Lambda";
+  return RuntimeName2;
+})(RuntimeName || {});
+
+export {
+  RuntimeName
+};

package/chunks/chunk-XNF5MLCQ.js

@@ -0,0 +1,14 @@
+// src/agnostic/objects/record-map/index.ts
+function recordMap(record, mapper) {
+  const result = {};
+  for (const key in record) {
+    if (Object.prototype.hasOwnProperty.call(record, key)) {
+      result[key] = mapper(record[key], key);
+    }
+  }
+  return result;
+}
+
+export {
+  recordMap
+};

package/chunks/chunk-XQUMWHCH.js

@@ -0,0 +1,25 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/ftps/file/download/index.ts
+import { PassThrough } from "node:stream";
+async function download(ftpClient, sourcePath, options) {
+  const { startAt } = options ?? {};
+  const stream = new PassThrough();
+  try {
+    await ftpClient.downloadTo(stream, sourcePath, startAt);
+    return makeSuccess(stream);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+export {
+  download
+};

package/chunks/chunk-YA2YCZUF.js

@@ -0,0 +1,8 @@
+// src/node/images/transform/operations/flop/index.ts
+async function flop(sharpInstance) {
+  return sharpInstance.flop();
+}
+
+export {
+  flop
+};

package/chunks/chunk-YDIBNEGA.js

@@ -0,0 +1,9 @@
+// src/agnostic/objects/is-record/index.ts
+function isRecord(input) {
+  if (typeof input !== "object" || input === null) return false;
+  return Object.keys(input).every((key) => typeof key === "string");
+}
+
+export {
+  isRecord
+};

package/chunks/chunk-YHMR7IBA.js

@@ -0,0 +1,24 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/file/exists/index.ts
+async function exists(bucket, sourcePath, options) {
+  const { fileOptions, existsOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    const [exists2] = await file.exists(existsOptions);
+    return makeSuccess(exists2);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+export {
+  exists
+};