@design-edito/tools 0.3.16 → 0.4.0

package/chunks/chunk-RKX6KLPQ.js

@@ -0,0 +1,47 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
+import { Buffer } from "node:buffer";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+function encryptUint8Array(fileArray, encryptionKey) {
+  const ivLength = 12;
+  const keyBuffer = Buffer.from(encryptionKey, "utf-8");
+  if (keyBuffer.length !== 32) return makeFailure("Encryption key must be 32 bytes for AES-256-GCM.");
+  try {
+    const iv = randomBytes(ivLength);
+    const cipher = createCipheriv("aes-256-gcm", keyBuffer, iv);
+    let encrypted = cipher.update(fileArray);
+    encrypted = Buffer.concat([encrypted, cipher.final()]);
+    return makeSuccess(new Uint8Array(Buffer.concat([iv, encrypted])));
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+function decryptUint8Array(encryptedFile, encryptionKey) {
+  const ivLength = 12;
+  const iv = encryptedFile.subarray(0, ivLength);
+  const keyBuffer = Buffer.from(encryptionKey, "utf-8");
+  if (keyBuffer.length !== 32) return makeFailure("Encryption key must be 32 bytes for AES-256-GCM.");
+  try {
+    const encryptedData = encryptedFile.subarray(ivLength);
+    const decipher = createDecipheriv("aes-256-gcm", keyBuffer, iv);
+    let decrypted = decipher.update(encryptedData);
+    decrypted = Buffer.concat([decrypted, decipher.final()]);
+    return makeSuccess(new Uint8Array(decrypted));
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+export {
+  encryptUint8Array,
+  decryptUint8Array
+};

package/chunks/chunk-RW7VAKJW.js

@@ -0,0 +1,15 @@
+// src/agnostic/html/hyper-json/method/index.ts
+var Method = class _Method {
+  transformer;
+  static clone(method) {
+    const { transformer } = method;
+    return new _Method(transformer);
+  }
+  constructor(transformer) {
+    this.transformer = transformer;
+  }
+};
+
+export {
+  Method
+};

package/chunks/chunk-RZOR7ZC3.js

@@ -0,0 +1,35 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@aws-s3/storage/file/exists/index.ts
+import {
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+async function exists(client, bucketName, sourcePath, options) {
+  const { headObjectOptions } = options ?? {};
+  try {
+    await client.send(
+      new HeadObjectCommand({
+        Bucket: bucketName,
+        Key: sourcePath,
+        ...headObjectOptions
+      })
+    );
+    return makeSuccess(true);
+  } catch (err) {
+    const notFound = err.$metadata?.httpStatusCode === 404 || err.name === "NotFound" || err.Code === "NotFound" || err.Code === "NoSuchKey";
+    if (notFound) {
+      return makeSuccess(false);
+    }
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  exists
+};

package/chunks/chunk-S2UZ3HZR.js

@@ -0,0 +1,31 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/sftp/file/stat/index.ts
+async function stat(sftp, path) {
+  try {
+    const info = await sftp.stat(path);
+    return makeSuccess({
+      size: info.size,
+      modifiedAt: new Date(info.modifyTime * 1e3),
+      mode: info.mode,
+      uid: info.uid,
+      gid: info.gid,
+      raw: info
+    });
+  } catch (err) {
+    if (err.code === 2 || err.code === "ENOENT") {
+      return makeFailure(`File not found: ${path}`);
+    }
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  stat
+};

package/chunks/chunk-SPC2SMZR.js

@@ -0,0 +1,82 @@
+import {
+  intersectionObserver
+} from "./chunk-3DNVFA25.js";
+import {
+  clss
+} from "./chunk-TRFZSKNB.js";
+import {
+  mergeClassNames
+} from "./chunk-OFCSIK6J.js";
+
+// src/components/IntersectionObserver/index.tsx
+import {
+  useState,
+  useRef,
+  useEffect,
+  useCallback
+} from "react";
+
+// src/components/IntersectionObserver/styles.module.css
+var styles_default = {};
+
+// src/components/IntersectionObserver/index.tsx
+import { jsx } from "react/jsx-runtime";
+var IntersectionObserverComponent = ({
+  onIntersected,
+  root,
+  rootMargin,
+  threshold,
+  className,
+  children
+}) => {
+  const [ioEntry, setIoEntry] = useState(null);
+  const rootRef = useRef(null);
+  const observerRef = useRef(null);
+  const observation = useCallback((entries, observer) => {
+    const thisEntry = entries[0];
+    if (thisEntry === void 0) return setIoEntry(null);
+    onIntersected?.({ ioEntry: thisEntry, observer });
+    setIoEntry(thisEntry);
+  }, [onIntersected]);
+  const forceObservation = useCallback(() => {
+    const rootEl = rootRef.current;
+    const observer = observerRef.current;
+    if (rootEl === null || observer === null) return;
+    observer.unobserve(rootEl);
+    observer.observe(rootEl);
+  }, []);
+  useEffect(() => {
+    const rootEl = rootRef.current;
+    if (rootEl === null) return console.warn("rootRef.current should not be null");
+    const observer = new IntersectionObserver(observation, { root, rootMargin, threshold });
+    observerRef.current = observer;
+    observer.observe(rootEl);
+    return () => observer.disconnect();
+  }, [root, rootMargin, threshold, observation]);
+  useEffect(() => {
+    const timeout1 = window.setTimeout(forceObservation, 100);
+    const timeout2 = window.setTimeout(forceObservation, 500);
+    return () => {
+      window.clearTimeout(timeout1);
+      window.clearTimeout(timeout2);
+    };
+  }, [forceObservation]);
+  const c = clss(intersectionObserver, { cssModule: styles_default });
+  const isIntersecting = ioEntry?.isIntersecting ?? false;
+  const rootClss = mergeClassNames(
+    c(null, { "is-intersecting": isIntersecting }),
+    className
+  );
+  return /* @__PURE__ */ jsx(
+    "div",
+    {
+      className: rootClss,
+      ref: rootRef,
+      children
+    }
+  );
+};
+
+export {
+  IntersectionObserverComponent
+};

package/chunks/chunk-SYH5LYQC.js

@@ -0,0 +1,28 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/sftp/file/remove/index.ts
+async function remove(sftp, targetPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  try {
+    const exists = await sftp.exists(targetPath) !== false;
+    if (!exists) {
+      if (ignoreMissing) return makeSuccess(true);
+      return makeFailure(`File not found at ${targetPath}.`);
+    }
+    await sftp.delete(targetPath);
+    return makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+export {
+  remove
+};

package/chunks/chunk-TAXFCVFE.js

@@ -0,0 +1,30 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/sftp/directory/move-dir/index.ts
+async function moveDir(sftp, sourceDir, targetDir, options) {
+  const { overwrite = false, ensureDir = true } = options ?? {};
+  try {
+    if (ensureDir) {
+      const parentDir = targetDir.substring(0, targetDir.lastIndexOf("/"));
+      await sftp.mkdir(parentDir, true);
+    }
+    if (!overwrite) {
+      const exists = await sftp.exists(targetDir);
+      if (exists !== false) return makeFailure(`Target ${targetDir} already exists.`);
+    }
+    await sftp.rename(sourceDir, targetDir);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  moveDir
+};

package/chunks/chunk-TNZGRXKJ.js

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

package/chunks/chunk-TRFZSKNB.js

@@ -0,0 +1,32 @@
+// src/agnostic/css/clss/index.ts
+function clss(blockNames, options) {
+  const blockNamesArr = Array.isArray(blockNames) ? blockNames : [blockNames];
+  return (eltNames = null, modNames = []) => {
+    const eltNamesArr = Array.isArray(eltNames) ? eltNames : [eltNames];
+    const modNamesArr = (Array.isArray(modNames) ? modNames : [modNames]).map((modName) => {
+      if (typeof modName === "string") return modName;
+      const trueModNames = Object.entries(modName).filter((entry) => entry[1] === true).map(([key]) => key);
+      return trueModNames;
+    }).flat();
+    const outputClassesArr = [];
+    blockNamesArr.forEach((compName) => {
+      eltNamesArr.forEach((eltName) => {
+        const targetPublicClss = eltName === null ? compName : `${compName}__${eltName}`;
+        const targetPrivateClss = eltName === null ? options?.cssModule[options.cssModuleRoot ?? "root"] : options?.cssModule[eltName];
+        outputClassesArr.push(targetPublicClss);
+        if (targetPrivateClss !== void 0) outputClassesArr.push(targetPrivateClss);
+        modNamesArr.forEach((modName) => {
+          const targetModifiedPublicClss = `${targetPublicClss}--${modName}`;
+          const targetModifiedPrivateClss = eltName === null ? options?.cssModule[`${options.cssModuleRoot ?? "root"}--${modName}`] : options?.cssModule[`${eltName}--${modName}`];
+          outputClassesArr.push(targetModifiedPublicClss);
+          if (targetModifiedPrivateClss !== void 0) outputClassesArr.push(targetModifiedPrivateClss);
+        });
+      });
+    });
+    return outputClassesArr.join(" ");
+  };
+}
+
+export {
+  clss
+};

package/chunks/chunk-U664BT44.js

@@ -0,0 +1,45 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@aws-s3/storage/file/copy/index.ts
+import {
+  CopyObjectCommand,
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+async function copy(client, bucketName, sourcePath, targetPath, options) {
+  const {
+    copyOptions,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (!overwrite) {
+      try {
+        await client.send(new HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+        return makeFailure(`Object already exists at ${targetPath}.`);
+      } catch (err) {
+        const notFound = err.$metadata?.httpStatusCode === 404 || err.name === "NotFound";
+        if (!notFound) throw err;
+      }
+    }
+    await client.send(
+      new CopyObjectCommand({
+        Bucket: bucketName,
+        Key: targetPath,
+        CopySource: `${bucketName}/${sourcePath}`,
+        ...copyOptions
+      })
+    );
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copy
+};

package/chunks/chunk-U6SGKHHA.js

@@ -0,0 +1,32 @@
+import {
+  toSharpColor
+} from "./chunk-HMMPT3UM.js";
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  isColor
+} from "./chunk-OBSTP7YR.js";
+
+// src/node/images/transform/operations/rotate/index.ts
+import z from "zod";
+function isRotateOperationParams(obj) {
+  const schema = z.object({
+    angleDeg: z.number().optional(),
+    background: z.custom(isColor).optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function rotate(sharpInstance, params) {
+  return sharpInstance.rotate(params.angleDeg, {
+    background: params.background !== void 0 ? toSharpColor(params.background) : void 0
+  });
+}
+
+export {
+  isRotateOperationParams,
+  rotate
+};

package/chunks/chunk-UTQNGKGQ.js

@@ -0,0 +1,60 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@aws-s3/storage/directory/remove-dir/index.ts
+import {
+  ListObjectsV2Command,
+  DeleteObjectsCommand
+} from "@aws-sdk/client-s3";
+async function removeDir(client, bucketName, directoryPath, options) {
+  const {
+    listObjectsOptions,
+    deleteObjectsOptions,
+    ignoreMissing = true
+  } = options ?? {};
+  const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+  let continuationToken;
+  let anyFound = false;
+  try {
+    do {
+      const listResp = await client.send(
+        new ListObjectsV2Command({
+          Bucket: bucketName,
+          Prefix: prefix,
+          ContinuationToken: continuationToken,
+          ...listObjectsOptions
+        })
+      );
+      const keys = (listResp.Contents ?? []).map((o) => o.Key).filter((e) => e !== void 0);
+      if (keys.length > 0) {
+        anyFound = true;
+        for (let i = 0; i < keys.length; i += 1e3) {
+          const chunk = keys.slice(i, i + 1e3);
+          await client.send(
+            new DeleteObjectsCommand({
+              Bucket: bucketName,
+              Delete: { Objects: chunk.map((Key) => ({ Key })) },
+              ...deleteObjectsOptions
+            })
+          );
+        }
+      }
+      continuationToken = listResp.IsTruncated === true ? listResp.NextContinuationToken : void 0;
+    } while (continuationToken !== void 0);
+    if (!anyFound && !ignoreMissing) {
+      return makeFailure(`No objects found for prefix "${prefix}".`);
+    }
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  removeDir
+};

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
+};