@design-edito/tools 0.4.4 → 0.4.6

package/node/@aws-s3/storage/file/exists/index.js

@@ -1,9 +1,37 @@
-import {
-  exists
-} from "../../../../../chunks/chunk-RZOR7ZC3.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  exists
-};
+import { HeadObjectCommand } from '@aws-sdk/client-s3';
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Checks whether an object exists in a specified S3 bucket (AWS SDK v3).
+ *
+ * @param {S3Client} client          - The v3 S3 client instance.
+ * @param {string}   bucketName      - The name of the S3 bucket.
+ * @param {string}   sourcePath      - The key of the object to test.
+ * @param {ExistsOptions} [options]  - Optional configuration.
+ * @param {Omit<HeadObjectCommandInput,'Bucket'|'Key'>} [options.headObjectOptions] - Extra `HeadObject` params.
+ * @returns {Promise<Outcome.Either<boolean, string>>}
+ * - Success: `Outcome.makeSuccess(true)` if the object exists,
+ *            `Outcome.makeSuccess(false)` if it does not.
+ * - Failure: `Outcome.makeFailure(errStr)` for unexpected errors.
+ */
+export async function exists(client, bucketName, sourcePath, options) {
+    const { headObjectOptions } = options ?? {};
+    try {
+        await client.send(new HeadObjectCommand({
+            Bucket: bucketName,
+            Key: sourcePath,
+            ...headObjectOptions
+        }));
+        return Outcome.makeSuccess(true);
+    }
+    catch (err) {
+        const notFound = err.$metadata?.httpStatusCode === 404
+            || err.name === 'NotFound'
+            || err.Code === 'NotFound' // some SDKs emit Code
+            || err.Code === 'NoSuchKey';
+        if (notFound) {
+            return Outcome.makeSuccess(false);
+        }
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@aws-s3/storage/file/index.d.ts

@@ -1,6 +1,6 @@
-export * as copy from './copy/index.js'
 export * as download from './download/index.js'
 export * as exists from './exists/index.js'
+export * as copy from './copy/index.js'
 export * as move from './move/index.js'
 export * as remove from './remove/index.js'
 export * as stat from './stat/index.js'

package/node/@aws-s3/storage/file/index.js

@@ -1,6 +1,6 @@
-export * as copy from './copy/index.js'
 export * as download from './download/index.js'
 export * as exists from './exists/index.js'
+export * as copy from './copy/index.js'
 export * as move from './move/index.js'
 export * as remove from './remove/index.js'
 export * as stat from './stat/index.js'

package/node/@aws-s3/storage/file/move/index.js

@@ -1,9 +1,60 @@
-import {
-  move
-} from "../../../../../chunks/chunk-LJ5MGLLU.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  move
-};
+import { HeadObjectCommand, CopyObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Moves an object from one key to another within the same S3 bucket (AWS SDK v3).
+ *
+ * The function copies the object from `sourcePath` to `targetPath` and, upon
+ * successful copy, deletes the original object.
+ *
+ * @param {S3Client} client - The S3 client instance.
+ * @param {string}   bucketName - The name of the bucket.
+ * @param {string}   sourcePath - The source object's key.
+ * @param {string}   targetPath - The destination object's key.
+ * @param {MoveOptions} [options] - Optional copy/delete behaviour.
+ * @param {Omit<CopyObjectCommandInput,'Bucket'|'Key'|'CopySource'>} [options.copyOptions]   - Extra copy params.
+ * @param {Omit<DeleteObjectCommandInput,'Bucket'|'Key'>}            [options.deleteOptions] - Extra delete params.
+ * @param {boolean} [options.overwrite=false] - Whether to overwrite an existing `targetPath`.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ * - Success: `Outcome.makeSuccess(true)`
+ * - Failure: `Outcome.makeFailure(errStr)`
+ */
+export async function move(client, bucketName, sourcePath, targetPath, options) {
+    const { copyOptions, deleteOptions, overwrite = false } = options ?? {};
+    try {
+        // Abort early if destination exists and overwrite is disabled
+        if (!overwrite) {
+            try {
+                await client.send(new HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+                return Outcome.makeFailure(`Object already exists at ${targetPath}.`);
+            }
+            catch (err) {
+                const notFound = err.$metadata?.httpStatusCode === 404
+                    || err.name === 'NotFound'
+                    || err.Code === 'NotFound'
+                    || err.Code === 'NoSuchKey';
+                if (!notFound) {
+                    return Outcome.makeFailure(unknownToString(err));
+                }
+                // If not found, proceed with copy
+            }
+        }
+        // Copy to the new key
+        await client.send(new CopyObjectCommand({
+            Bucket: bucketName,
+            Key: targetPath,
+            CopySource: `${bucketName}/${sourcePath}`,
+            ...copyOptions
+        }));
+        // Delete the original key
+        await client.send(new DeleteObjectCommand({
+            Bucket: bucketName,
+            Key: sourcePath,
+            ...deleteOptions
+        }));
+        return Outcome.makeSuccess(true);
+    }
+    catch (err) {
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@aws-s3/storage/file/remove/index.js

@@ -1,9 +1,38 @@
-import {
-  remove
-} from "../../../../../chunks/chunk-AP3VYSVF.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  remove
-};
+import { HeadObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Removes a file from a specified Amazon S3 bucket (AWS SDK v3).
+ *
+ * If `ignoreMissing` is true (default), a missing object is considered success.
+ *
+ * @param {S3Client} s3 - The AWS S3 client instance.
+ * @param {string} bucketName - The name of the bucket.
+ * @param {string} targetPath - The key of the object to delete.
+ * @param {RemoveOptions} [options] - Optional settings.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ */
+export async function remove(s3, bucketName, targetPath, options) {
+    const { ignoreMissing = true } = options ?? {};
+    try {
+        // Check if object exists, respecting ignoreMissing
+        try {
+            await s3.send(new HeadObjectCommand({ Bucket: bucketName, Key: targetPath }));
+        }
+        catch (err) {
+            const code = err?.name ?? err?.Code ?? err?.code;
+            if (code === 'NotFound' || code === 'NoSuchKey' || code === 'NotFoundException') {
+                if (ignoreMissing)
+                    return Outcome.makeSuccess(true);
+                return Outcome.makeFailure(`File not found at ${targetPath}.`);
+            }
+            return Outcome.makeFailure(unknownToString(err));
+        }
+        // Delete the object
+        await s3.send(new DeleteObjectCommand({ Bucket: bucketName, Key: targetPath }));
+        return Outcome.makeSuccess(true);
+    }
+    catch (err) {
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@aws-s3/storage/file/stat/index.js

@@ -1,9 +1,34 @@
-import {
-  stat
-} from "../../../../../chunks/chunk-IRKZUMWZ.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  stat
-};
+import { HeadObjectCommand } from '@aws-sdk/client-s3';
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Retrieves metadata for a single S3 object.
+ *
+ * @param {S3Client} client – v3 S3 client.
+ * @param {string}   bucket – Bucket name.
+ * @param {string}   key    – Object key.
+ * @param {StatOptions} [options] – Extra HeadObject params.
+ * @returns {Promise<Outcome.Either<Stat, string>>}
+ */
+export async function stat(client, bucket, key, options) {
+    const { headObjectOptions } = options ?? {};
+    try {
+        const res = await client.send(new HeadObjectCommand({ Bucket: bucket, Key: key, ...headObjectOptions }));
+        const stat = {
+            size: res.ContentLength,
+            modifiedAt: res.LastModified,
+            checksum: res.ETag?.replace(/"/g, ''),
+            contentType: res.ContentType,
+            metadata: res.Metadata,
+            storageClass: res.StorageClass,
+            raw: res
+        };
+        return Outcome.makeSuccess(stat);
+    }
+    catch (err) {
+        const notFound = err.$metadata?.httpStatusCode === 404 || err.name === 'NotFound';
+        if (notFound)
+            return Outcome.makeFailure(`Object not found: ${key}`);
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@aws-s3/storage/file/upload/index.js

@@ -1,9 +1,55 @@
-import {
-  upload
-} from "../../../../../chunks/chunk-WIFHP4X7.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  upload
-};
+import { HeadObjectCommand } from '@aws-sdk/client-s3';
+import { Upload } from '@aws-sdk/lib-storage';
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Uploads a file stream to a specified Amazon S3 bucket using AWS SDK v3.
+ *
+ * If `overwrite` is false and the target file exists, upload is aborted.
+ *
+ * @param {S3Client} s3 - The AWS S3 v3 client instance.
+ * @param {string} bucketName - The S3 bucket name.
+ * @param {string} targetPath - The key to upload the file to.
+ * @param {Readable} fileStream - The file content as a stream.
+ * @param {UploadOptions} [options] - Optional configuration.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ */
+export 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);
+            // If no error, object exists
+            return Outcome.makeFailure(`File already exists at ${targetPath}.`);
+        }
+        catch (err) {
+            const code = err?.name ?? err?.$metadata?.httpStatusCode;
+            if (code !== 'NotFound' && code !== 404) {
+                return Outcome.makeFailure(unknownToString(err));
+            }
+            // Object not found, proceed with upload
+        }
+    }
+    const params = {
+        ...fileMetadata,
+        Bucket: bucketName,
+        Key: targetPath,
+        Body: fileStream
+    };
+    try {
+        const upload = new Upload({
+            client: s3,
+            params,
+            ...uploadSettings
+        });
+        await upload.done();
+        return Outcome.makeSuccess(true);
+    }
+    catch (err) {
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@design-edito/index.js

@@ -0,0 +1 @@
+export {};

package/node/@express/@multer/index.js

@@ -1,47 +1,63 @@
-import {
-  makeFailure,
-  makeSuccess
-} from "../../../chunks/chunk-LUAYN7VJ.js";
-import {
-  unknownToString
-} from "../../../chunks/chunk-PUQUSA6S.js";
-import "../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/node/@express/@multer/index.ts
-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(makeFailure({
-      code: err.code,
-      message: err.message,
-      field: err.field
+import multer from 'multer';
+import * as Outcome from '../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Applies multer middleware to an Express request/response pair.
+ *
+ * The function creates a multer instance based on the provided options and
+ * applies the appropriate middleware based on the upload mode. Errors are
+ * captured and returned as a structured `WithMulterError` object.
+ *
+ * @param {Request} req                    - The Express request object.
+ * @param {Response} res                   - The Express response object.
+ * @param {WithMulterOptions} options      - Multer configuration and upload mode.
+ * @param {multer.StorageEngine} [options.storage] - Storage engine (defaults to memory).
+ * @param {multer.Options['limits']} [options.limits] - File size and count limits.
+ * @param {multer.Options['fileFilter']} [options.fileFilter] - File filter function.
+ * @param {'none'|'any'|'single'|'array'|'fields'} options.mode - Upload mode.
+ * @param {string} [options.fieldName]     - Field name (required for 'single' and 'array' modes).
+ * @param {number} [options.maxCount]      - Max file count (for 'array' mode).
+ * @param {multer.Field[]} [options.fields] - Field configurations (for 'fields' mode).
+ * @returns {Promise<Outcome.Either<true, WithMulterError>>}
+ * - On success:  `Outcome.makeSuccess(true)`.
+ * - On failure:  `Outcome.makeFailure(error)` with structured error details.
+ */
+export async function useMulterMiddleware(req, res, options) {
+    // eslint-disable-next-line @typescript-eslint/unbound-method
+    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 !== undefined
+            ? Outcome.makeFailure({
+                code: 'UNKNOWN',
+                message: unknownToString(err)
+            })
+            : Outcome.makeSuccess(true));
     }));
-    return resolve(
-      err !== void 0 ? makeFailure({
-        code: "UNKNOWN",
-        message: unknownToString(err)
-      }) : makeSuccess(true)
-    );
-  }));
 }
-export {
-  useMulterMiddleware
-};

package/node/@google-cloud/storage/bucket/get-metadata/index.js

@@ -1,22 +1,26 @@
-import {
-  makeFailure,
-  makeSuccess
-} from "../../../../../chunks/chunk-LUAYN7VJ.js";
-import {
-  unknownToString
-} from "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-
-// src/node/@google-cloud/storage/bucket/get-metadata/index.ts
-async function getMetadata(bucket, options) {
-  try {
-    const [metadata] = await bucket.getMetadata(options);
-    return makeSuccess(metadata);
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return makeFailure(errStr);
-  }
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+/**
+ * Retrieves metadata for a Google Cloud Storage bucket.
+ *
+ * This function calls the Google Cloud Storage API to get information about the bucket,
+ * such as its location, storage class, and other configuration details.
+ *
+ * @param {Bucket} bucket - The Google Cloud Storage bucket object.
+ * @param {GetBucketMetadataOptions} [options] - Optional configuration options to pass to the `getMetadata` method.
+ * @returns {Promise<Outcome.Either<BucketMetadata, string>>} A promise that resolves to an `Outcome.Either`.
+ * - On success: `Outcome.makeSuccess(metadata)` with the bucket metadata.
+ * - On failure: `Outcome.makeFailure(errStr)` with an error message.
+ *
+ * @throws {Error} Throws an error if the metadata retrieval fails (e.g., network issues, incorrect permissions).
+ */
+export async function getMetadata(bucket, options) {
+    try {
+        const [metadata] = await bucket.getMetadata(options);
+        return Outcome.makeSuccess(metadata);
+    }
+    catch (err) {
+        const errStr = unknownToString(err);
+        return Outcome.makeFailure(errStr);
+    }
 }
-export {
-  getMetadata
-};

package/node/@google-cloud/storage/directory/copy-dir/index.js

@@ -1,9 +1,38 @@
-import {
-  copyDir
-} from "../../../../../chunks/chunk-WZS4Q3G3.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  copyDir
-};
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/** Recursively copies every object under `sourceDir` to the same relative path
+ *  beneath `targetDir` within a single GCS bucket.
+ * @param {Bucket} bucket - The GCS bucket instance.
+ * @param {string} sourceDir - The source directory path (prefix) to copy from.
+ * @param {string} targetDir - The target directory path (prefix) to copy to.
+ * @param {CopyDirOptions} [options] - Optional parameters for the operation.
+ * @param {boolean} [options.overwrite=false] - Whether to overwrite existing files at target.
+ * @returns {Promise<Outcome.Either<true, string>>} A promise that resolves to an `Outcome.Either`:
+ * - On success: `Outcome.makeSuccess(true)` indicating the copy was successful.
+ * - On failure: `Outcome.makeFailure(errStr)` with an error message if the copy fails.
+ * */
+export 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) {
+                    // Skip copy if target exists and overwrite is false
+                    continue;
+                }
+            }
+            await f.copy(dest, copyOptions);
+        }
+        return Outcome.makeSuccess(true);
+    }
+    catch (err) {
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@google-cloud/storage/directory/list/index.js

@@ -1,9 +1,29 @@
-import {
-  list
-} from "../../../../../chunks/chunk-REXSJULD.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  list
-};
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Lists all direct children file paths under a given directory prefix in a GCS bucket.
+ *
+ * This function returns only the immediate files (not recursive) under the specified directory prefix.
+ *
+ * @param {Bucket} bucket - The GCS bucket to list files from.
+ * @param {string} directoryPath - The directory prefix to list files under.
+ * @param {ListOptions} [options] - Optional configuration for the listing.
+ * @param {FileOptions} [options.fileOptions] - Additional options for file retrieval.
+ * @returns {Promise<Outcome.Either<string[], string>>} Returns either a success with an array of file paths, or a failure with an error message.
+ */
+export 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 Outcome.makeSuccess(paths);
+    }
+    catch (err) {
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@google-cloud/storage/directory/move-dir/index.js

@@ -1,9 +1,45 @@
-import {
-  moveDir
-} from "../../../../../chunks/chunk-OAX7GS7C.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  moveDir
-};
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Recursively moves every object under `sourceDir` to the corresponding path
+ * under `targetDir` within the same bucket.
+ *
+ * Example: moving `a/b/` to `x/y/` copies
+ * `a/b/file.txt` → `x/y/file.txt` and then deletes the original.
+ *
+ * If `overwrite` is false (default), the operation aborts if any destination file
+ * already exists.
+ *
+ * @param {Bucket} bucket - The GCS bucket instance.
+ * @param {string} sourceDir - The source directory prefix to move from.
+ * @param {string} targetDir - The target directory prefix to move to.
+ * @param {MoveDirOptions} [options] - Optional parameters for the operation.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ * - On success: `Outcome.makeSuccess(true)`.
+ * - On failure: `Outcome.makeFailure(errStr)`.
+ */
+export async function moveDir(bucket, sourceDir, targetDir, options) {
+    const { fileOptions, copyOptions, deleteOptions, overwrite = false } = options ?? {};
+    const from = sourceDir.endsWith('/') ? sourceDir : `${sourceDir}/`;
+    const to = targetDir.endsWith('/') ? targetDir : `${targetDir}/`;
+    try {
+        const [files] = await bucket.getFiles({ prefix: from });
+        for (const f of files) {
+            const rel = f.name.substring(from.length);
+            const dest = `${to}${rel}`;
+            const srcFile = bucket.file(f.name, fileOptions);
+            const destFile = bucket.file(dest, fileOptions);
+            if (!overwrite) {
+                const [exists] = await destFile.exists();
+                if (exists)
+                    throw new Error(`File already exists at ${dest}.`);
+            }
+            await srcFile.copy(dest, copyOptions);
+            await srcFile.delete(deleteOptions);
+        }
+        return Outcome.makeSuccess(true);
+    }
+    catch (err) {
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}

package/node/@google-cloud/storage/directory/remove-dir/index.js

@@ -1,9 +1,36 @@
-import {
-  removeDir
-} from "../../../../../chunks/chunk-GQBFMP6N.js";
-import "../../../../../chunks/chunk-LUAYN7VJ.js";
-import "../../../../../chunks/chunk-PUQUSA6S.js";
-import "../../../../../chunks/chunk-WSFCRVEQ.js";
-export {
-  removeDir
-};
+import * as Outcome from '../../../../../agnostic/misc/outcome/index.js';
+import { unknownToString } from '../../../../../agnostic/errors/unknown-to-string/index.js';
+/**
+ * Recursively deletes all objects under a directory prefix in a GCS bucket
+ * (including the directory placeholder itself, if present).
+ *
+ * @param {Bucket} bucket - The GCS bucket instance.
+ * @param {string} directoryPath - The “directory” prefix to delete.
+ * @param {RemoveDirOptions} [options] - Optional configuration.
+ * @param {GCSDeleteFileOptions & {force?: boolean}} [options.deleteOptions] - Extra delete parameters.
+ * @param {boolean} [options.ignoreMissing=true] - Whether to ignore an empty/missing prefix.
+ * @returns {Promise<Outcome.Either<true, string>>}
+ * - On success: `Outcome.makeSuccess(true)` if deletion succeeds
+ *   (or prefix absent and `ignoreMissing` is true).
+ * - On failure: `Outcome.makeFailure(errStr)` if deletion fails
+ *   or prefix absent and `ignoreMissing` is false.
+ */
+export async function removeDir(bucket, directoryPath, options) {
+    const { deleteOptions, ignoreMissing = true } = options ?? {};
+    const prefix = directoryPath.endsWith('/') ? directoryPath : `${directoryPath}/`;
+    try {
+        // First check if anything exists when ignoreMissing is disabled.
+        if (!ignoreMissing) {
+            const [some] = await bucket.getFiles({ prefix, maxResults: 1 });
+            if (some.length === 0) {
+                return Outcome.makeFailure(`No objects found for prefix "${prefix}".`);
+            }
+        }
+        // deleteFiles removes all matching objects in a single call.
+        await bucket.deleteFiles({ prefix, ...deleteOptions });
+        return Outcome.makeSuccess(true);
+    }
+    catch (err) {
+        return Outcome.makeFailure(unknownToString(err));
+    }
+}