@design-edito/tools 0.3.16 → 0.3.17

package/chunks/chunk-3QI2MSDK.js

@@ -0,0 +1,34 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/file/copy/index.ts
+async function copy(bucket, sourcePath, targetPath, options) {
+  const {
+    fileOptions,
+    copyOptions,
+    overwrite = false
+  } = options ?? {};
+  try {
+    const srcFile = bucket.file(sourcePath, fileOptions);
+    const destFile = bucket.file(targetPath, fileOptions);
+    if (!overwrite) {
+      const [destExists] = await destFile.exists();
+      if (destExists) {
+        return makeFailure(`Object already exists at ${targetPath}.`);
+      }
+    }
+    await srcFile.copy(destFile, copyOptions);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copy
+};

package/chunks/chunk-3RNLPW7B.js

@@ -0,0 +1,101 @@
+import {
+  isDuckTypedSharpInstance,
+  toSharpInstance
+} from "./chunk-HMMPT3UM.js";
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  isColor
+} from "./chunk-OBSTP7YR.js";
+
+// src/node/images/transform/operations/overlay/index.ts
+import sharp from "sharp";
+import z from "zod";
+function isOverlayOperationParams(obj) {
+  const schema = z.object({
+    input: z.union([
+      z.custom(isDuckTypedSharpInstance),
+      z.custom((data) => Buffer.isBuffer(data)),
+      z.string(),
+      z.object({
+        width: z.number().optional(),
+        height: z.number().optional(),
+        channels: z.union([z.literal(3), z.literal(4)]).optional(),
+        background: z.custom(isColor).optional(),
+        noise: z.object({
+          mean: z.number().optional(),
+          sigma: z.number().optional()
+        }).optional(),
+        pageHeight: z.number().optional()
+      })
+    ]),
+    top: z.number().optional(),
+    left: z.number().optional(),
+    tile: z.boolean().optional(),
+    premultiplied: z.boolean().optional(),
+    density: z.number().optional(),
+    animated: z.boolean().optional(),
+    autoOrient: z.boolean().optional(),
+    ignoreIcc: z.boolean().optional(),
+    pages: z.number().optional(),
+    page: z.number().optional(),
+    blend: z.enum([
+      "clear",
+      "source",
+      "over",
+      "in",
+      "out",
+      "atop",
+      "dest",
+      "dest-over",
+      "dest-in",
+      "dest-out",
+      "dest-atop",
+      "xor",
+      "add",
+      "saturate",
+      "multiply",
+      "screen",
+      "overlay",
+      "darken",
+      "lighten",
+      "color-dodge",
+      "colour-dodge",
+      "color-burn",
+      "colour-burn",
+      "hard-light",
+      "soft-light",
+      "difference",
+      "exclusion"
+    ]).optional(),
+    gravity: z.enum([
+      "north",
+      "northeast",
+      "southeast",
+      "south",
+      "southwest",
+      "west",
+      "northwest",
+      "east",
+      "center",
+      "centre"
+    ]).optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function overlay(sharpInstance, params) {
+  const inputBuffer = params.input instanceof Buffer ? params.input : await (await toSharpInstance(params.input)).toBuffer();
+  return sharp(await sharpInstance.composite([{
+    ...params,
+    input: inputBuffer
+  }]).webp().toBuffer());
+}
+
+export {
+  isOverlayOperationParams,
+  overlay
+};

package/chunks/chunk-3RZMW72G.js

@@ -0,0 +1,33 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@aws-s3/storage/directory/list/index.ts
+import {
+  ListObjectsV2Command
+} from "@aws-sdk/client-s3";
+async function list(client, bucketName, directoryPath, options) {
+  const prefix = directoryPath.endsWith("/") ? directoryPath : `${directoryPath}/`;
+  try {
+    const response = await client.send(
+      new ListObjectsV2Command({
+        Bucket: bucketName,
+        Prefix: prefix,
+        Delimiter: "/",
+        ...options
+      })
+    );
+    const keys = (response.Contents ?? []).map((obj) => obj.Key).filter((e) => e !== void 0);
+    return makeSuccess(keys);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  list
+};

package/chunks/chunk-4KLCJX2T.js

@@ -0,0 +1,36 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/file/move/index.ts
+async function move(bucket, sourcePath, targetPath, options) {
+  const {
+    fileOptions,
+    copyOptions,
+    deleteOptions,
+    overwrite = false
+  } = options ?? {};
+  try {
+    const srcFile = bucket.file(sourcePath, fileOptions);
+    const destFile = bucket.file(targetPath, fileOptions);
+    if (!overwrite) {
+      const [exists] = await destFile.exists();
+      if (exists) {
+        return makeFailure(`Object already exists at ${targetPath}.`);
+      }
+    }
+    await srcFile.copy(destFile, copyOptions);
+    await srcFile.delete(deleteOptions);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  move
+};

package/chunks/chunk-4LTN4SCD.js

@@ -0,0 +1,55 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/ftps/directory/copy-dir/index.ts
+import { PassThrough } from "node:stream";
+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/chunks/chunk-4Q4T7QQO.js

@@ -0,0 +1,27 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/file/download/index.ts
+async function download(bucket, sourcePath, options) {
+  const { fileOptions, downloadOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    const stream = file.createReadStream(downloadOptions);
+    stream.on("error", (err) => {
+      throw err;
+    });
+    return makeSuccess(stream);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return makeFailure(errStr);
+  }
+}
+
+export {
+  download
+};

package/chunks/chunk-4Q5TKOIG.js

@@ -0,0 +1,53 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/sftp/directory/copy-dir/index.ts
+import { PassThrough } from "node:stream";
+async function copyDir(sftp, sourceDir, targetDir, options) {
+  const {
+    overwrite = false,
+    ensureDir = true,
+    ...transferOptions
+  } = options ?? {};
+  async function recurse(dir) {
+    const list = await sftp.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.type === "d") {
+        if (ensureDir) await sftp.mkdir(dst, true);
+        await recurse(src);
+      } else if (entry.type === "-") {
+        if (!overwrite) {
+          const exists = await sftp.exists(dst);
+          if (exists !== false) throw new Error(`File already exists at ${dst}.`);
+        }
+        if (ensureDir) {
+          const dirPath = dst.substring(0, dst.lastIndexOf("/"));
+          await sftp.mkdir(dirPath, true);
+        }
+        const pass = new PassThrough();
+        const upload = sftp.put(pass, dst, transferOptions);
+        await sftp.get(src, pass, transferOptions);
+        await upload;
+      }
+    }
+  }
+  try {
+    if (ensureDir) await sftp.mkdir(targetDir, true);
+    await recurse(sourceDir);
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  copyDir
+};

package/chunks/chunk-4STX5SQX.js

@@ -0,0 +1,131 @@
+import {
+  Method
+} from "./chunk-RW7VAKJW.js";
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+
+// src/agnostic/html/hyper-json/transformer/index.ts
+var Transformer = class _Transformer {
+  name;
+  mode;
+  innerValue;
+  typeChecks;
+  func;
+  sourceTree;
+  static clone(transformer) {
+    const { name, mode, innerValue, typeChecks, func, sourceTree } = transformer;
+    return new _Transformer(name, mode, innerValue, typeChecks, func, sourceTree);
+  }
+  constructor(name, mode, innerValue, typeChecks, func, sourceTree) {
+    this.apply = this.apply.bind(this);
+    this.getMainAndArgsValue = this.getMainAndArgsValue.bind(this);
+    this.makeMainValueError = this.makeMainValueError.bind(this);
+    this.makeArgsValueError = this.makeArgsValueError.bind(this);
+    this.makeTransformationError = this.makeTransformationError.bind(this);
+    this.toMethod = this.toMethod.bind(this);
+    this.name = name;
+    this.mode = mode;
+    this.innerValue = innerValue;
+    this.typeChecks = typeChecks;
+    this.func = func;
+    this.sourceTree = sourceTree;
+  }
+  getMainAndArgsValue(outerValue) {
+    const { mode, innerValue } = this;
+    let mainValue;
+    let argsValue;
+    if (mode === "isolation") {
+      if (Array.isArray(innerValue)) {
+        mainValue = innerValue.at(0) ?? [];
+        argsValue = innerValue.slice(1);
+      } else {
+        mainValue = innerValue;
+        argsValue = [];
+      }
+    } else {
+      mainValue = outerValue;
+      argsValue = Array.isArray(innerValue) ? innerValue : [innerValue];
+    }
+    return { mainValue, argsValue };
+  }
+  makeMainValueError(mainValue, argsValue, expected, found, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "BAD_MAIN_VALUE",
+      expected,
+      found,
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  makeArgsValueError(mainValue, argsValue, expected, found, position, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "BAD_ARGUMENTS_VALUE",
+      expected,
+      found,
+      position,
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  makeTransformationError(mainValue, argsValue, details) {
+    const { name, sourceTree } = this;
+    return {
+      message: "TRANSFORMATION_ERROR",
+      details,
+      transformerName: name,
+      path: sourceTree.pathString,
+      mainValue,
+      argsValue
+    };
+  }
+  apply(outerValue) {
+    const getMainAndArgsValue = this.getMainAndArgsValue.bind(this);
+    const makeMainValueError = this.makeMainValueError.bind(this);
+    const makeArgsValueError = this.makeArgsValueError.bind(this);
+    const makeTransformationError = this.makeTransformationError.bind(this);
+    const func = this.func.bind(this);
+    const { typeChecks } = this;
+    const { mainValue, argsValue } = getMainAndArgsValue(outerValue);
+    const mainChecked = typeChecks.mainValue(mainValue);
+    if (!mainChecked.success) return makeFailure(makeMainValueError(
+      mainValue,
+      argsValue,
+      mainChecked.error.expected,
+      mainChecked.error.found
+    ));
+    const validMainValue = mainChecked.payload;
+    const argsChecked = typeChecks.argsValue(argsValue, validMainValue);
+    if (!argsChecked.success) return makeFailure(makeArgsValueError(
+      mainValue,
+      argsValue,
+      argsChecked.error.expected,
+      argsChecked.error.found,
+      argsChecked.error.position
+    ));
+    const validArgsValue = argsChecked.payload;
+    const called = func(validMainValue, validArgsValue, { name: this.name, sourceTree: this.sourceTree });
+    if (!called.success) return makeFailure(makeTransformationError(
+      mainValue,
+      argsValue,
+      called.error
+    ));
+    return makeSuccess(called.payload);
+  }
+  toMethod() {
+    return new Method(this);
+  }
+};
+
+export {
+  Transformer
+};

package/chunks/chunk-57YKZBJR.js

@@ -0,0 +1,29 @@
+// src/agnostic/misc/crossenv/window/index.ts
+function exists() {
+  return typeof globalThis !== "undefined" && "window" in globalThis;
+}
+var _window = exists() ? globalThis.window ?? null : null;
+function set(customWindow) {
+  _window = customWindow;
+  return customWindow;
+}
+function unset() {
+  if (exists()) {
+    _window = globalThis.window;
+  } else {
+    _window = null;
+  }
+  return _window;
+}
+function get() {
+  if (_window !== null) return _window;
+  const message = "window is undefined. Please call Window.setWindow(windowObj) before using Window.get.";
+  throw new Error(message);
+}
+
+export {
+  exists,
+  set,
+  unset,
+  get
+};

package/chunks/chunk-5H3IRSOB.js

@@ -0,0 +1,8 @@
+// src/agnostic/misc/is-constructor-function/index.ts
+function isConstructorFunction(input) {
+  return typeof input === "function" && "prototype" in input && typeof input.prototype === "object" && "constructor" in input.prototype && input.prototype.constructor === input;
+}
+
+export {
+  isConstructorFunction
+};

package/chunks/chunk-5NTPCRFH.js

@@ -0,0 +1,32 @@
+// src/node/images/types.ts
+var OpName = /* @__PURE__ */ ((OpName2) => {
+  OpName2["BLUR"] = "blur";
+  OpName2["BRIGHTEN"] = "brighten";
+  OpName2["EXTEND"] = "extend";
+  OpName2["EXTRACT"] = "extract";
+  OpName2["FLATTEN"] = "flatten";
+  OpName2["FLIP"] = "flip";
+  OpName2["FLOP"] = "flop";
+  OpName2["HUE"] = "hue";
+  OpName2["LEVEL"] = "level";
+  OpName2["LIGHTEN"] = "lighten";
+  OpName2["NORMALIZE"] = "normalize";
+  OpName2["OVERLAY"] = "overlay";
+  OpName2["RESIZE"] = "resize";
+  OpName2["ROTATE"] = "rotate";
+  OpName2["SATURATE"] = "saturate";
+  return OpName2;
+})(OpName || {});
+var TransformErrCodes = /* @__PURE__ */ ((TransformErrCodes2) => {
+  TransformErrCodes2["PROCESS_TIMEOUT"] = "process-timeout";
+  TransformErrCodes2["OP_TIMEOUT"] = "op-timeout";
+  TransformErrCodes2["WIDTH_LIMIT_EXCEEDED"] = "width-limit-exceeded";
+  TransformErrCodes2["HEIGHT_LIMIT_EXCEEDED"] = "height-limit-exceeded";
+  TransformErrCodes2["UNKNOWN_ERROR"] = "unknown-error";
+  return TransformErrCodes2;
+})(TransformErrCodes || {});
+
+export {
+  OpName,
+  TransformErrCodes
+};

package/chunks/chunk-5TM235Z3.js

@@ -0,0 +1,40 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// 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);
+  }
+}
+
+export {
+  upload
+};

package/chunks/chunk-5WVGUZL5.js

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

package/chunks/chunk-6XL25OZX.js

@@ -0,0 +1,12 @@
+// src/agnostic/strings/trim/index.ts
+function trimStart(string) {
+  return string.replace(/^\s*/, "");
+}
+function trimEnd(string) {
+  return string.replace(/\s*$/, "");
+}
+
+export {
+  trimStart,
+  trimEnd
+};

package/chunks/chunk-75BICI4L.js

@@ -0,0 +1,20 @@
+import {
+  randomHexChar
+} from "./chunk-OGBUSUE6.js";
+
+// src/agnostic/random/uuid/index.ts
+function randomHash(length = 4) {
+  return new Array(length).fill(null).map(randomHexChar).join("");
+}
+function randomHashPattern(pattern, joiner = "-") {
+  return pattern.map(randomHash).join(joiner);
+}
+function randomUUID() {
+  return randomHashPattern([8, 4, 4, 4, 12]);
+}
+
+export {
+  randomHash,
+  randomHashPattern,
+  randomUUID
+};

package/chunks/chunk-77SWZUHV.js

@@ -0,0 +1,31 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/file/stat/index.ts
+async function stat(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));
+  }
+}
+
+export {
+  stat
+};