@design-edito/tools 0.3.16 → 0.3.17

package/chunks/chunk-QXAJXTXV.js

@@ -0,0 +1,19 @@
+import {
+  nullishValues
+} from "./chunk-HC6ZOHCS.js";
+
+// src/agnostic/booleans/is-falsy/index.ts
+var falsyValues = [...nullishValues, false, "", 0, -0, NaN];
+if (typeof BigInt === "function") falsyValues.push(BigInt(0));
+function isFalsy(val) {
+  return falsyValues.includes(val);
+}
+function isNotFalsy(val) {
+  return !isFalsy(val);
+}
+
+export {
+  falsyValues,
+  isFalsy,
+  isNotFalsy
+};

package/chunks/chunk-R3AWQXMY.js

@@ -0,0 +1,20 @@
+// src/agnostic/strings/matches/index.ts
+function matches(input, matcher) {
+  if (typeof matcher === "string") return input === matcher;
+  if (typeof matcher === "function") return matcher(input);
+  return input.match(matcher) !== null;
+}
+function matchesSome(input, matchers) {
+  if (!Array.isArray(matchers)) return matches(input, matchers);
+  return matchers.some((matcher) => matches(input, matcher));
+}
+function matchesEvery(input, matchers) {
+  if (!Array.isArray(matchers)) return matches(input, matchers);
+  return matchers.every((matcher) => matches(input, matcher));
+}
+
+export {
+  matches,
+  matchesSome,
+  matchesEvery
+};

package/chunks/chunk-R66GH2MQ.js

@@ -0,0 +1,38 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/sftp/file/copy/index.ts
+import { PassThrough } from "node:stream";
+async function copy(sftp, sourcePath, targetPath, options) {
+  const {
+    overwrite = false,
+    ensureDir = true,
+    ...transferOptions
+  } = options ?? {};
+  try {
+    if (!overwrite) {
+      const exists = await sftp.exists(targetPath);
+      if (exists !== false) return makeFailure(`File already exists at ${targetPath}.`);
+    }
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      await sftp.mkdir(dirPath, true);
+    }
+    const pass = new PassThrough();
+    const uploadPromise = sftp.put(pass, targetPath, transferOptions);
+    await sftp.get(sourcePath, pass, transferOptions);
+    await uploadPromise;
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copy
+};

package/chunks/chunk-RART44AF.js

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

package/chunks/chunk-REXSJULD.js

@@ -0,0 +1,28 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/directory/list/index.ts
+async function list(bucket, directoryPath, options) {
+  const { fileOptions } = options ?? {};
+  try {
+    const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+    const [files] = await bucket.getFiles({
+      prefix,
+      delimiter: "/",
+      ...fileOptions
+    });
+    const paths = files.map((file) => file.name);
+    return makeSuccess(paths);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  list
+};

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