@design-edito/tools 0.1.71 → 0.1.73

package/chunks/chunk-NMYVJJXV.js

@@ -0,0 +1,47 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/ftps/file/copy/index.ts
+var copy_exports = {};
+__export(copy_exports, {
+  copy: () => copy
+});
+import { PassThrough } from "node:stream";
+async function copy(ftpClient, sourcePath, targetPath, options) {
+  const {
+    overwrite = false,
+    ensureDir = true
+  } = options ?? {};
+  try {
+    if (!overwrite) {
+      try {
+        await ftpClient.size(targetPath);
+        return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+      } catch {
+      }
+    }
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      if (dirPath) await ftpClient.ensureDir(dirPath);
+    }
+    const pass = new PassThrough();
+    const uploadPromise = ftpClient.uploadFrom(pass, targetPath);
+    await ftpClient.downloadTo(pass, sourcePath);
+    await uploadPromise;
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copy,
+  copy_exports
+};

package/chunks/chunk-NOLQR5RW.js

@@ -0,0 +1,42 @@
+import {
+  upload as upload4
+} from "./chunk-FB3GNE2B.js";
+import {
+  upload as upload3
+} from "./chunk-FD5WR2A5.js";
+import {
+  upload as upload2
+} from "./chunk-QDVDHFMZ.js";
+import {
+  upload
+} from "./chunk-CVDCTI7F.js";
+import {
+  isFtpClient,
+  isGcsBucket,
+  isS3ClientWithBucket,
+  isSftpClient
+} from "./chunk-V3GX7SIJ.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/upload-file/index.ts
+var upload_file_exports = {};
+__export(upload_file_exports, {
+  uploadFile: () => uploadFile
+});
+async function uploadFile(fileStream, path, client, options) {
+  if (isGcsBucket(client)) return upload4(client, path, fileStream, options);
+  if (isS3ClientWithBucket(client)) return upload3(client.client, client.bucketName, path, fileStream, options);
+  if (isFtpClient(client)) return upload(client, path, fileStream, options);
+  if (isSftpClient(client)) return upload2(client, path, fileStream, options);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  uploadFile,
+  upload_file_exports
+};

package/chunks/chunk-OA7Y2A5T.js

@@ -0,0 +1,42 @@
+import {
+  copy as copy4
+} from "./chunk-CWZFRUBS.js";
+import {
+  copy as copy3
+} from "./chunk-C6QTHDDM.js";
+import {
+  copy as copy2
+} from "./chunk-QH64MYGA.js";
+import {
+  copy
+} from "./chunk-NMYVJJXV.js";
+import {
+  isFtpClient,
+  isGcsBucket,
+  isS3ClientWithBucket,
+  isSftpClient
+} from "./chunk-V3GX7SIJ.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/copy-file/index.ts
+var copy_file_exports = {};
+__export(copy_file_exports, {
+  copyFile: () => copyFile
+});
+async function copyFile(client, sourcePath, targetPath, options) {
+  if (isGcsBucket(client)) return copy4(client, sourcePath, targetPath, options);
+  if (isS3ClientWithBucket(client)) return copy3(client.client, client.bucketName, sourcePath, targetPath, options);
+  if (isFtpClient(client)) return copy(client, sourcePath, targetPath, options);
+  if (isSftpClient(client)) return copy2(client, sourcePath, targetPath, options);
+  return Outcome.makeFailure("Invalid client type");
+}
+
+export {
+  copyFile,
+  copy_file_exports
+};

package/chunks/chunk-OD7GR6ZF.js

@@ -0,0 +1,56 @@
+import {
+  remove_file_exports
+} from "./chunk-H4LW6FP3.js";
+import {
+  move_dir_exports
+} from "./chunk-FS6LRTDK.js";
+import {
+  remove_dir_exports
+} from "./chunk-CA3UPHYO.js";
+import {
+  move_file_exports
+} from "./chunk-646R6BQZ.js";
+import {
+  upload_file_exports
+} from "./chunk-NOLQR5RW.js";
+import {
+  stat_file_exports
+} from "./chunk-UK4HNSEJ.js";
+import {
+  copy_dir_exports
+} from "./chunk-6NLNUGBI.js";
+import {
+  copy_file_exports
+} from "./chunk-OA7Y2A5T.js";
+import {
+  download_file_exports
+} from "./chunk-EOTOFHUR.js";
+import {
+  exists_file_exports
+} from "./chunk-24ZUWYIR.js";
+import {
+  list_dir_exports
+} from "./chunk-DPQRXSZH.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/cloud-storage/operations/index.ts
+var operations_exports = {};
+__export(operations_exports, {
+  CopyDir: () => copy_dir_exports,
+  CopyFile: () => copy_file_exports,
+  DownloadFile: () => download_file_exports,
+  ExistsFile: () => exists_file_exports,
+  ListDir: () => list_dir_exports,
+  MoveDir: () => move_dir_exports,
+  MoveFile: () => move_file_exports,
+  RemoveDir: () => remove_dir_exports,
+  RemoveFile: () => remove_file_exports,
+  StatFile: () => stat_file_exports,
+  UploadFile: () => upload_file_exports
+});
+
+export {
+  operations_exports
+};

package/chunks/chunk-ON6LC3HE.js

@@ -0,0 +1,84 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@aws-s3/storage/directory/move-dir/index.ts
+var move_dir_exports = {};
+__export(move_dir_exports, {
+  moveDir: () => moveDir
+});
+import {
+  ListObjectsV2Command,
+  CopyObjectCommand,
+  DeleteObjectCommand,
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+async function moveDir(client, bucketName, sourceDir, targetDir, options) {
+  const {
+    listObjectsOptions,
+    copyOptions,
+    deleteOptions,
+    overwrite = false
+  } = options ?? {};
+  const from = sourceDir.endsWith("/") ? sourceDir : `${sourceDir}/`;
+  const to = targetDir.endsWith("/") ? targetDir : `${targetDir}/`;
+  try {
+    let token;
+    do {
+      const listResp = await client.send(
+        new ListObjectsV2Command({
+          Bucket: bucketName,
+          Prefix: from,
+          ContinuationToken: token,
+          ...listObjectsOptions
+        })
+      );
+      for (const obj of listResp.Contents ?? []) {
+        if (!obj.Key) continue;
+        const rel = obj.Key.substring(from.length);
+        const dest = `${to}${rel}`;
+        if (!overwrite) {
+          try {
+            await client.send(
+              new HeadObjectCommand({ Bucket: bucketName, Key: dest })
+            );
+            throw new Error(`Object already exists at ${dest}.`);
+          } catch (err) {
+            if (err.$metadata?.httpStatusCode !== 404 && err.name !== "NotFound")
+              throw err;
+          }
+        }
+        await client.send(
+          new CopyObjectCommand({
+            Bucket: bucketName,
+            Key: dest,
+            CopySource: `${bucketName}/${obj.Key}`,
+            ...copyOptions
+          })
+        );
+        await client.send(
+          new DeleteObjectCommand({
+            Bucket: bucketName,
+            Key: obj.Key,
+            ...deleteOptions
+          })
+        );
+      }
+      token = listResp.IsTruncated ? listResp.NextContinuationToken : void 0;
+    } while (token);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  moveDir,
+  move_dir_exports
+};

package/chunks/chunk-PAIUCLVK.js

@@ -0,0 +1,35 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/file/generate-signed-url/index.ts
+var generate_signed_url_exports = {};
+__export(generate_signed_url_exports, {
+  generateSignedUrl: () => generateSignedUrl
+});
+async function generateSignedUrl(bucket, sourcePath, action, expiresOn, options) {
+  const { fileOptions, getSignedUrlOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    const [url] = await file.getSignedUrl({
+      action,
+      expires: expiresOn,
+      ...getSignedUrlOptions
+    });
+    return Outcome.makeSuccess(url);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  generateSignedUrl,
+  generate_signed_url_exports
+};

package/chunks/chunk-QCOO4PV5.js

@@ -0,0 +1,54 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@express/@multer/index.ts
+var multer_exports = {};
+__export(multer_exports, {
+  useMulterMiddleware: () => useMulterMiddleware
+});
+import multer from "multer";
+async function useMulterMiddleware(req, res, options) {
+  const { storage, limits, fileFilter } = options;
+  const uploader = multer({
+    storage: storage ?? multer.memoryStorage(),
+    limits,
+    fileFilter
+  });
+  let middleware;
+  if (options.mode === "none") {
+    middleware = uploader.none();
+  } else if (options.mode === "single") {
+    middleware = uploader.single(options.fieldName);
+  } else if (options.mode === "array") {
+    middleware = uploader.array(options.fieldName, options.maxCount);
+  } else if (options.mode === "fields") {
+    middleware = uploader.fields(options.fields);
+  } else {
+    middleware = uploader.any();
+  }
+  return await new Promise((resolve) => middleware(req, res, (err) => {
+    if (err instanceof multer.MulterError) return resolve(Outcome.makeFailure({
+      code: err.code,
+      message: err.message,
+      field: err.field
+    }));
+    return resolve(
+      err !== void 0 ? Outcome.makeFailure({
+        code: "UNKNOWN",
+        message: unknownToString(err)
+      }) : Outcome.makeSuccess(true)
+    );
+  }));
+}
+
+export {
+  useMulterMiddleware,
+  multer_exports
+};

package/chunks/chunk-QDVDHFMZ.js

@@ -0,0 +1,39 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/sftp/file/upload/index.ts
+var upload_exports = {};
+__export(upload_exports, {
+  upload: () => upload
+});
+async function upload(sftp, targetPath, fileStream, options) {
+  const {
+    ensureDir = true,
+    overwrite = false
+  } = options ?? {};
+  try {
+    const exists = await sftp.exists(targetPath);
+    if (exists && !overwrite) return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      await sftp.mkdir(dirPath, true);
+    }
+    await sftp.put(fileStream, targetPath, options);
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  upload,
+  upload_exports
+};

package/chunks/chunk-QH64MYGA.js

@@ -0,0 +1,45 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/sftp/file/copy/index.ts
+var copy_exports = {};
+__export(copy_exports, {
+  copy: () => copy
+});
+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) return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+    }
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      if (dirPath) 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 Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copy,
+  copy_exports
+};

package/chunks/chunk-QLDN574K.js

@@ -0,0 +1,39 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-WSFCRVEQ.js";
+
+// src/node/@google-cloud/storage/directory/remove-dir/index.ts
+var remove_dir_exports = {};
+__export(remove_dir_exports, {
+  removeDir: () => removeDir
+});
+async function removeDir(bucket, directoryPath, options) {
+  const {
+    deleteOptions,
+    ignoreMissing = true
+  } = options ?? {};
+  const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+  try {
+    if (!ignoreMissing) {
+      const [some] = await bucket.getFiles({ prefix, maxResults: 1 });
+      if (some.length === 0) {
+        return Outcome.makeFailure(`No objects found for prefix "${prefix}".`);
+      }
+    }
+    await bucket.deleteFiles({ prefix, ...deleteOptions });
+    return Outcome.makeSuccess(true);
+  } catch (err) {
+    return Outcome.makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  removeDir,
+  remove_dir_exports
+};

package/chunks/chunk-QLOMT4DL.js

@@ -0,0 +1,21 @@
+import {
+  colorSchema
+} from "./chunk-DTETQT5O.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+import {
+  esm_default
+} from "./chunk-QPHK5QI7.js";
+
+// src/node/images/transform/flatten/index.ts
+var flattenSchema = esm_default.object({
+  name: esm_default.literal(OperationNames.Flatten),
+  params: esm_default.object({
+    background: colorSchema
+  })
+});
+
+export {
+  flattenSchema
+};