@design-edito/tools 0.4.3 → 0.4.5

package/node/cloud-storage/operations/stat-file/index.js

@@ -1,26 +1,116 @@
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/cloud-storage/clients/index.ts
+import { Bucket as GCSBucket } from "@google-cloud/storage";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+var isGcsBucket = (client) => client instanceof GCSBucket;
+var isS3ClientWithBucket = (client) => "bucketName" in client && typeof client.bucketName === "string" && "client" in client && client.client instanceof S3Client;
+var isFtpClient = (client) => client instanceof FtpClient;
+var isSftpClient = (client) => client instanceof SftpClient;
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/file/stat/index.ts
+async function stat(ftp, path) {
+  try {
+    const slash = path.lastIndexOf("/");
+    const dir = slash === -1 ? "." : path.slice(0, slash) || "/";
+    const name = slash === -1 ? path : path.slice(slash + 1);
+    const list = await ftp.list(dir);
+    const entry = list.find((e) => e.name === name && e.isFile);
+    if (entry === void 0) return makeFailure(`File not found: ${path}`);
+    return makeSuccess({
+      size: entry.size,
+      modifiedAt: entry.modifiedAt ?? void 0,
+      permissions: entry.rawModifiedAt.toString(),
+      raw: entry
+    });
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/sftp/file/stat/index.ts
+async function stat2(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));
+  }
+}
+
+// src/node/@aws-s3/storage/file/stat/index.ts
 import {
-  stat as stat4
-} from "../../../../chunks/chunk-77SWZUHV.js";
-import {
-  stat as stat3
-} from "../../../../chunks/chunk-IRKZUMWZ.js";
-import {
-  stat as stat2
-} from "../../../../chunks/chunk-S2UZ3HZR.js";
-import {
-  stat
-} from "../../../../chunks/chunk-IPRWXI27.js";
-import {
-  isFtpClient,
-  isGcsBucket,
-  isS3ClientWithBucket,
-  isSftpClient
-} from "../../../../chunks/chunk-ISJONMNA.js";
-import {
-  makeFailure
-} from "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+async function stat3(client, bucket, key, options) {
+  const { headObjectOptions } = options ?? {};
+  try {
+    const res = await client.send(
+      new HeadObjectCommand({ Bucket: bucket, Key: key, ...headObjectOptions })
+    );
+    const stat5 = {
+      size: res.ContentLength,
+      modifiedAt: res.LastModified,
+      checksum: res.ETag?.replace(/"/g, ""),
+      contentType: res.ContentType,
+      metadata: res.Metadata,
+      storageClass: res.StorageClass,
+      raw: res
+    };
+    return makeSuccess(stat5);
+  } catch (err) {
+    const notFound = err.$metadata?.httpStatusCode === 404 || err.name === "NotFound";
+    if (notFound) return makeFailure(`Object not found: ${key}`);
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@google-cloud/storage/file/stat/index.ts
+async function stat4(bucket, path, options) {
+  const { fileOptions, getMetadataOptions } = options ?? {};
+  try {
+    const [meta] = await bucket.file(path, fileOptions).getMetadata(getMetadataOptions);
+    const res = {
+      size: meta.size !== void 0 ? Number(meta.size) : void 0,
+      modifiedAt: meta.updated !== void 0 ? new Date(meta.updated) : void 0,
+      checksum: meta.md5Hash ?? meta.crc32c,
+      contentType: meta.contentType,
+      metadata: meta.metadata,
+      storageClass: meta.storageClass,
+      raw: meta
+    };
+    return makeSuccess(res);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
 
 // src/node/cloud-storage/operations/stat-file/index.ts
 async function statFile(client, path, options) {

package/node/cloud-storage/operations/upload-file/index.js

@@ -1,26 +1,154 @@
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/cloud-storage/clients/index.ts
+import { Bucket as GCSBucket } from "@google-cloud/storage";
+import { S3Client } from "@aws-sdk/client-s3";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+var isGcsBucket = (client) => client instanceof GCSBucket;
+var isS3ClientWithBucket = (client) => "bucketName" in client && typeof client.bucketName === "string" && "client" in client && client.client instanceof S3Client;
+var isFtpClient = (client) => client instanceof FtpClient;
+var isSftpClient = (client) => client instanceof SftpClient;
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/file/upload/index.ts
+async function upload(ftpClient, targetPath, fileStream, options) {
+  const {
+    ensureDir = true,
+    overwrite = false
+  } = options ?? {};
+  try {
+    if (ensureDir) {
+      const dirPath = targetPath.substring(0, targetPath.lastIndexOf("/"));
+      await ftpClient.ensureDir(dirPath);
+    }
+    let fileExists = false;
+    try {
+      await ftpClient.size(targetPath);
+      fileExists = true;
+    } catch {
+      fileExists = false;
+    }
+    if (fileExists && !overwrite) {
+      return makeFailure(`File already exists at ${targetPath}.`);
+    }
+    await ftpClient.uploadFrom(fileStream, targetPath, options);
+    return makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+// src/node/sftp/file/upload/index.ts
+async function upload2(sftp, targetPath, fileStream, options) {
+  const {
+    ensureDir = true,
+    overwrite = false
+  } = options ?? {};
+  try {
+    const exists = await sftp.exists(targetPath) !== false;
+    if (exists && !overwrite) return 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 makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+// src/node/@aws-s3/storage/file/upload/index.ts
 import {
-  upload as upload4
-} from "../../../../chunks/chunk-EX2QKFY5.js";
-import {
-  upload as upload3
-} from "../../../../chunks/chunk-WIFHP4X7.js";
-import {
-  upload as upload2
-} from "../../../../chunks/chunk-H3HRQ52T.js";
-import {
-  upload
-} from "../../../../chunks/chunk-5TM235Z3.js";
-import {
-  isFtpClient,
-  isGcsBucket,
-  isS3ClientWithBucket,
-  isSftpClient
-} from "../../../../chunks/chunk-ISJONMNA.js";
-import {
-  makeFailure
-} from "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+import { Upload } from "@aws-sdk/lib-storage";
+async function upload3(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 upload5 = new Upload({
+      client: s3,
+      params,
+      ...uploadSettings
+    });
+    await upload5.done();
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+// src/node/@google-cloud/storage/file/upload/index.ts
+async function upload4(bucket, targetPath, fileStream, options) {
+  const { fileOptions, saveOptions, overwrite = false } = options ?? {};
+  const file = bucket.file(targetPath, fileOptions);
+  if (!overwrite) {
+    try {
+      const [exists] = await file.exists();
+      if (exists) {
+        return makeFailure(`File already exists at ${targetPath}.`);
+      }
+    } catch (err) {
+      const errStr = unknownToString(err);
+      return makeFailure(errStr);
+    }
+  }
+  try {
+    await new Promise((resolve, reject) => {
+      const writeStream = file.createWriteStream(saveOptions);
+      fileStream.pipe(writeStream);
+      fileStream.on("error", reject);
+      writeStream.on("finish", resolve);
+      writeStream.on("error", reject);
+    });
+    return makeSuccess(true);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
 
 // src/node/cloud-storage/operations/upload-file/index.ts
 async function uploadFile(fileStream, path, client, options) {

package/node/encryption/@aes-256-gcm/buffer/index.js

@@ -1,26 +1,72 @@
-import {
-  decryptUint8Array,
-  encryptUint8Array
-} from "../../../../chunks/chunk-RKX6KLPQ.js";
-import {
-  makeSuccess
-} from "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+// src/node/encryption/@aes-256-gcm/buffer/index.ts
+import { Buffer as Buffer3 } from "node:buffer";
+
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
+function encryptUint8Array(fileArray, encryptionKey) {
+  const ivLength = 12;
+  const keyBuffer = Buffer2.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 = Buffer2.concat([encrypted, cipher.final()]);
+    return makeSuccess(new Uint8Array(Buffer2.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 = Buffer2.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 = Buffer2.concat([decrypted, decipher.final()]);
+    return makeSuccess(new Uint8Array(decrypted));
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
 
 // src/node/encryption/@aes-256-gcm/buffer/index.ts
-import { Buffer } from "node:buffer";
 function encrypt(inputBuffer, encryptionKey) {
   const fileArray = new Uint8Array(inputBuffer);
   const encryptionOutcome = encryptUint8Array(fileArray, encryptionKey);
   if (!encryptionOutcome.success) return encryptionOutcome;
-  return makeSuccess(Buffer.from(encryptionOutcome.payload));
+  return makeSuccess(Buffer3.from(encryptionOutcome.payload));
 }
 function decrypt(encryptedBuffer, encryptionKey) {
   const encryptedArray = new Uint8Array(encryptedBuffer);
   const decryptionOutcome = decryptUint8Array(encryptedArray, encryptionKey);
   if (!decryptionOutcome.success) return decryptionOutcome;
-  return makeSuccess(Buffer.from(decryptionOutcome.payload));
+  return makeSuccess(Buffer3.from(decryptionOutcome.payload));
 }
 export {
   decrypt,

package/node/encryption/@aes-256-gcm/uint8-array/index.js

@@ -1,10 +1,56 @@
-import {
-  decryptUint8Array,
-  encryptUint8Array
-} from "../../../../chunks/chunk-RKX6KLPQ.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/node/encryption/@aes-256-gcm/uint8-array/index.ts
+function encryptUint8Array(fileArray, encryptionKey) {
+  const ivLength = 12;
+  const keyBuffer = Buffer2.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 = Buffer2.concat([encrypted, cipher.final()]);
+    return makeSuccess(new Uint8Array(Buffer2.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 = Buffer2.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 = Buffer2.concat([decrypted, decipher.final()]);
+    return makeSuccess(new Uint8Array(decrypted));
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
 export {
   decryptUint8Array,
   encryptUint8Array

package/node/encryption/key/index.js

@@ -1,5 +1,3 @@
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
 // src/node/encryption/key/index.ts
 import { pbkdf2Sync, randomBytes } from "node:crypto";
 function generate(passphrase, outputByteLength, options) {

package/node/files/index.d.ts

@@ -1,3 +1,3 @@
 export * as isInDirectory from './is-in-directory/index.js'
-export * as readWrite from './read-write/index.js'
 export * as subpaths from './subpaths/index.js'
+export * as readWrite from './read-write/index.js'

package/node/files/index.js

@@ -1,3 +1,3 @@
 export * as isInDirectory from './is-in-directory/index.js'
-export * as readWrite from './read-write/index.js'
 export * as subpaths from './subpaths/index.js'
+export * as readWrite from './read-write/index.js'

package/node/files/is-in-directory/index.js

@@ -1,5 +1,3 @@
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
 // src/node/files/is-in-directory/index.ts
 import path from "node:path";
 function isInDirectory(childPath, parentPath) {

package/node/files/read-write/index.js

@@ -1,5 +1,3 @@
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
 // src/node/files/read-write/index.ts
 import { promises as fs } from "node:fs";
 async function readWrite(path, editor, opts = {}) {

package/node/files/subpaths/index.js

@@ -1,11 +1,19 @@
-import {
-  matchesSome
-} from "../../../chunks/chunk-R3AWQXMY.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
 // src/node/files/subpaths/index.ts
 import { promises as fs } from "node:fs";
 import path from "node:path";
+
+// 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));
+}
+
+// src/node/files/subpaths/index.ts
 var defaultListContext = {
   depth: 0,
   lstats: null,

package/node/ftps/directory/copy-dir/index.js

@@ -1,9 +1,65 @@
-import {
-  copyDir
-} from "../../../../chunks/chunk-4LTN4SCD.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+// src/node/ftps/directory/copy-dir/index.ts
+import { PassThrough } from "node:stream";
+
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/directory/copy-dir/index.ts
+async function copyDir(ftpClient, sourceDir, targetDir, options) {
+  const {
+    overwrite = false,
+    ensureDir = true
+  } = options ?? {};
+  async function recurse(dir) {
+    const list = await ftpClient.list(dir);
+    for (const entry of list) {
+      const src = dir.endsWith("/") ? dir + entry.name : dir + "/" + entry.name;
+      const rel = src.substring(sourceDir.length + (sourceDir.endsWith("/") ? 0 : 1));
+      const dst = targetDir.endsWith("/") ? targetDir + rel : `${targetDir}/${rel}`;
+      if (entry.isDirectory) {
+        if (ensureDir) await ftpClient.ensureDir(dst);
+        await recurse(src);
+      } else if (entry.isFile) {
+        if (!overwrite) {
+          try {
+            await ftpClient.size(dst);
+            throw new Error(`File already exists at ${dst}.`);
+          } catch {
+          }
+        }
+        if (ensureDir) {
+          const dirPath = dst.substring(0, dst.lastIndexOf("/"));
+          await ftpClient.ensureDir(dirPath);
+        }
+        const pass = new PassThrough();
+        const upload = ftpClient.uploadFrom(pass, dst);
+        await ftpClient.downloadTo(pass, src);
+        await upload;
+      }
+    }
+  }
+  try {
+    if (ensureDir) await ftpClient.ensureDir(targetDir);
+    await recurse(sourceDir);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
 export {
   copyDir
 };

package/node/ftps/directory/list/index.js

@@ -1,9 +1,30 @@
-import {
-  list
-} from "../../../../chunks/chunk-E7BBN5JC.js";
-import "../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../chunks/chunk-WSFCRVEQ.js";
+// src/agnostic/misc/outcome/index.ts
+function makeSuccess(payload) {
+  return { success: true, payload };
+}
+function makeFailure(error) {
+  return { success: false, error };
+}
+
+// src/agnostic/errors/unknown-to-string/index.ts
+function unknownToString(unk, encoding) {
+  if (unk instanceof Error) return unk.message;
+  if (unk instanceof Buffer) return unk.toString(encoding ?? "utf-8");
+  if (typeof unk === "string") return unk;
+  if (typeof unk === "object" && unk !== null) return JSON.stringify(unk);
+  return `${unk}`;
+}
+
+// src/node/ftps/directory/list/index.ts
+async function list(ftpClient, directoryPath) {
+  try {
+    const list2 = await ftpClient.list(directoryPath);
+    const files = list2.filter((entry) => entry.isFile).map((entry) => directoryPath.endsWith("/") ? `${directoryPath}${entry.name}` : `${directoryPath}/${entry.name}`);
+    return makeSuccess(files);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
 export {
   list
 };