@design-edito/tools 0.3.16 → 0.3.17

package/chunks/chunk-E6MSDKON.js

@@ -0,0 +1,13 @@
+// src/agnostic/objects/enums/is-in-enum/index.ts
+function isInEnum(enumObj, value) {
+  const keys = Object.keys(enumObj);
+  const values = Object.values(enumObj);
+  const numericValues = values.filter((val) => typeof val === "number");
+  const cleanKeys = keys.filter((key) => !numericValues.includes(parseInt(key, 10)));
+  const cleanValues = cleanKeys.map((cleanKey) => enumObj[cleanKey]);
+  return cleanValues.includes(value);
+}
+
+export {
+  isInEnum
+};

package/chunks/chunk-E7BBN5JC.js

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

package/chunks/chunk-EPUHVR7J.js

@@ -0,0 +1,17 @@
+// src/agnostic/strings/replace-all/index.ts
+function replaceAll(input, pattern, replacer) {
+  console.warn("[DEPRECATED] Use String.replaceAll instead");
+  const found = Array.from(input.match(pattern) ?? []);
+  const foundReplaced = typeof replacer === "string" ? found.map(() => replacer) : found.map((e) => replacer(e));
+  const splitted = input.split(pattern);
+  const replaced = splitted.map((chunk, chunkPos) => {
+    const isLast = chunkPos === splitted.length - 1;
+    if (isLast) return [chunk];
+    return [chunk, foundReplaced[chunkPos] ?? ""];
+  }).flat().join("");
+  return replaced;
+}
+
+export {
+  replaceAll
+};

package/chunks/chunk-EX2QKFY5.js

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

package/chunks/chunk-EYYNCLVR.js

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

package/chunks/chunk-FCABYQRX.js

@@ -0,0 +1,37 @@
+import {
+  Transformer
+} from "./chunk-4STX5SQX.js";
+import {
+  Method
+} from "./chunk-RW7VAKJW.js";
+
+// src/agnostic/html/hyper-json/smart-tags/index.ts
+var SmartTags;
+((SmartTags2) => {
+  function makeSmartTag(descriptor) {
+    return [descriptor.name, {
+      defaultMode: descriptor.defaultMode,
+      isolationInitType: descriptor.isolationInitType,
+      generator: (innerValue, mode, sourceTree) => {
+        const transformer = new Transformer(
+          descriptor.name,
+          mode,
+          innerValue,
+          {
+            mainValue: descriptor.mainValueCheck,
+            argsValue: descriptor.argsValueCheck
+          },
+          descriptor.func,
+          sourceTree
+        );
+        const method = new Method(transformer);
+        return { transformer, method };
+      }
+    }];
+  }
+  SmartTags2.makeSmartTag = makeSmartTag;
+})(SmartTags || (SmartTags = {}));
+
+export {
+  SmartTags
+};

package/chunks/chunk-FJH35B3Q.js

@@ -0,0 +1,20 @@
+import {
+  SmartTags
+} from "./chunk-FCABYQRX.js";
+import {
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+
+// src/agnostic/html/hyper-json/smart-tags/isolated/null/index.ts
+var nullFunc = SmartTags.makeSmartTag({
+  name: "null",
+  defaultMode: "isolation",
+  isolationInitType: "null",
+  mainValueCheck: (i) => ({ success: true, payload: i }),
+  argsValueCheck: (a) => makeSuccess(a),
+  func: () => makeSuccess(null)
+});
+
+export {
+  nullFunc
+};

package/chunks/chunk-FSNNEPY5.js

@@ -0,0 +1,37 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/ftps/directory/remove-dir/index.ts
+async function removeDir(ftpClient, directoryPath, options) {
+  const { ignoreMissing = true } = options ?? {};
+  async function recurse(dir) {
+    const list = await ftpClient.list(dir);
+    for (const entry of list) {
+      const full = dir.endsWith("/") ? dir + entry.name : `${dir}/${entry.name}`;
+      if (entry.isDirectory) {
+        await recurse(full);
+      } else if (entry.isFile) {
+        await ftpClient.remove(full);
+      }
+    }
+    await ftpClient.removeDir(dir);
+  }
+  try {
+    await recurse(directoryPath);
+    return makeSuccess(true);
+  } catch (err) {
+    if (ignoreMissing && err.code === 550) {
+      return makeSuccess(true);
+    }
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  removeDir
+};

package/chunks/chunk-GQBFMP6N.js

@@ -0,0 +1,32 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@google-cloud/storage/directory/remove-dir/index.ts
+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 makeFailure(`No objects found for prefix "${prefix}".`);
+      }
+    }
+    await bucket.deleteFiles({ prefix, ...deleteOptions });
+    return makeSuccess(true);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  removeDir
+};

package/chunks/chunk-H3HRQ52T.js

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

package/chunks/chunk-H4KLHV6B.js

@@ -0,0 +1,78 @@
+import {
+  Transformer
+} from "./chunk-4STX5SQX.js";
+import {
+  Method
+} from "./chunk-RW7VAKJW.js";
+import {
+  get
+} from "./chunk-57YKZBJR.js";
+
+// src/agnostic/html/hyper-json/serialize/index.ts
+var Serialize;
+((Serialize2) => {
+  function serialize(value) {
+    const { Text, Element, NodeList } = get();
+    if (value === null) return { type: "null", value: null };
+    if (typeof value === "boolean" || typeof value === "number" || typeof value === "string") return { type: typeof value, value };
+    if (value instanceof Text) return { type: "text", value: value.textContent ?? "" };
+    if (value instanceof Element) return { type: "element", value: value.outerHTML };
+    if (value instanceof NodeList) return {
+      type: "nodelist",
+      value: Array.from(value).map(serialize)
+    };
+    if (Array.isArray(value)) return { type: "array", value: value.map(serialize) };
+    if (value instanceof Transformer) return { type: "transformer", value: Transformer.clone(value) };
+    if (value instanceof Method) return { type: "method", value: Method.clone(value) };
+    return {
+      type: "record",
+      value: Object.entries(value).reduce((reduced, [key, val]) => ({
+        ...reduced,
+        [key]: serialize(val)
+      }), {})
+    };
+  }
+  Serialize2.serialize = serialize;
+  function deserialize(serialized) {
+    const { document } = get();
+    if (serialized.type === "null") return null;
+    if (serialized.type === "boolean") return serialized.value;
+    if (serialized.type === "number") return serialized.value;
+    if (serialized.type === "string") return serialized.value;
+    if (serialized.type === "text") return document.createTextNode(serialized.value);
+    if (serialized.type === "element") {
+      const elt = document.createElement("div");
+      elt.innerHTML = serialized.value;
+      const firstChild = elt.firstElementChild;
+      return firstChild ?? document.createElement("div");
+    }
+    if (serialized.type === "nodelist") {
+      const frag = document.createDocumentFragment();
+      const deserialized = serialized.value.filter((e) => e.type === "text" || e.type === "element").map(deserialize);
+      deserialized.forEach((elt) => frag.append(elt.cloneNode(true)));
+      return frag.childNodes;
+    }
+    if (serialized.type === "array") {
+      const toRet = [];
+      for (const val of serialized.value) {
+        const deserialized = deserialize(val);
+        if (deserialized instanceof Transformer) continue;
+        toRet.push(deserialized);
+      }
+      return toRet;
+    }
+    if (serialized.type === "transformer") return Transformer.clone(serialized.value);
+    if (serialized.type === "method") return Method.clone(serialized.value);
+    return Object.entries(serialized.value).reduce((reduced, [key, serialized2]) => {
+      return {
+        ...reduced,
+        [key]: deserialize(serialized2)
+      };
+    }, {});
+  }
+  Serialize2.deserialize = deserialize;
+})(Serialize || (Serialize = {}));
+
+export {
+  Serialize
+};

package/chunks/chunk-H4PP6AHP.js

@@ -0,0 +1,15 @@
+// src/agnostic/misc/logs/make-text-block/index.ts
+function makeTextBlock(text, vPadding = 1, hPadding = vPadding) {
+  const lines = text.split("\n");
+  const longestLine = Math.max(...lines.map((line) => line.length));
+  const textBlockArr = new Array(lines.length + 2 * vPadding).fill(null).map(() => new Array(longestLine + hPadding * 2).fill(" "));
+  lines.forEach((line, linePos) => {
+    const chars = line.split("");
+    textBlockArr[linePos + vPadding]?.splice(hPadding, chars.length, ...chars);
+  });
+  return textBlockArr.map((lineArr) => lineArr.join("")).join("\n");
+}
+
+export {
+  makeTextBlock
+};

package/chunks/chunk-HC6ZOHCS.js

@@ -0,0 +1,14 @@
+// src/agnostic/misc/is-nullish/index.ts
+var nullishValues = [null, void 0];
+function isNullish(val) {
+  return nullishValues.includes(val);
+}
+function isNotNullish(val) {
+  return !isNullish(val);
+}
+
+export {
+  nullishValues,
+  isNullish,
+  isNotNullish
+};

package/chunks/chunk-HMMPT3UM.js

@@ -0,0 +1,47 @@
+import {
+  tidy,
+  toRgb
+} from "./chunk-CVMYA5XK.js";
+import {
+  isNonNullObject
+} from "./chunk-HQLRJ7XW.js";
+
+// src/node/images/utils/index.ts
+import { readFile } from "node:fs/promises";
+import sharp from "sharp";
+function toSharpColor(color) {
+  const rgb = tidy(toRgb(color));
+  return {
+    r: rgb.r,
+    g: rgb.g,
+    b: rgb.b,
+    alpha: rgb.a
+  };
+}
+function isDuckTypedSharpInstance(obj) {
+  if (!isNonNullObject(obj)) return false;
+  return "avif" in obj && "clone" in obj && "gif" in obj && "heif" in obj && "jpeg" in obj && "heif" in obj && "metadata" in obj && "png" in obj && "resize" in obj && "tiff" in obj && "webp" in obj && typeof obj.avif === "function" && typeof obj.clone === "function" && typeof obj.gif === "function" && typeof obj.heif === "function" && typeof obj.jpeg === "function" && typeof obj.heif === "function" && typeof obj.metadata === "function" && typeof obj.png === "function" && typeof obj.resize === "function" && typeof obj.tiff === "function" && typeof obj.webp === "function";
+}
+function toCreateOptions(options) {
+  return {
+    width: options.width ?? 100,
+    height: options.height ?? 100,
+    channels: options.channels ?? 4,
+    background: options.background !== void 0 ? toSharpColor(options.background) : toSharpColor("white"),
+    noise: options.noise !== void 0 ? { ...options.noise, type: "gaussian" } : void 0,
+    pageHeight: options.pageHeight
+  };
+}
+async function toSharpInstance(imageLike, clone = false) {
+  if (typeof imageLike === "string") return sharp(await readFile(imageLike));
+  if (Buffer.isBuffer(imageLike)) return sharp(imageLike);
+  if (isDuckTypedSharpInstance(imageLike)) return clone ? imageLike.clone() : imageLike;
+  return sharp({ create: toCreateOptions(imageLike) });
+}
+
+export {
+  toSharpColor,
+  isDuckTypedSharpInstance,
+  toCreateOptions,
+  toSharpInstance
+};

package/chunks/chunk-HQLRJ7XW.js

@@ -0,0 +1,12 @@
+// src/agnostic/objects/is-object/index.ts
+function isObject(unk) {
+  return typeof unk === "object";
+}
+function isNonNullObject(unk) {
+  return unk !== null && isObject(unk);
+}
+
+export {
+  isObject,
+  isNonNullObject
+};

package/chunks/chunk-HYPEWMYZ.js

@@ -0,0 +1,10 @@
+// src/agnostic/sanitization/file-name/index.ts
+function sanitizeFileName(input, maxLength = 255) {
+  input = input.normalize("NFKC").replace(/[<>:"/\\|?*\x00-\x1F]/g, "").trim().replace(/\s+/g, " ").replace(/\.+/g, ".").replace(/^\.+|\.+$/g, "");
+  if (input.length > maxLength) return null;
+  return input.length > 0 ? input : null;
+}
+
+export {
+  sanitizeFileName
+};

package/chunks/chunk-I5MRXMHR.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/flatten/index.ts
+import z from "zod";
+function isFlattenOperationParams(obj) {
+  const schema = z.object({
+    background: z.custom(isColor).optional()
+  });
+  const result = schema.safeParse(obj);
+  if (!result.success) return makeFailure(result.error.message);
+  return makeSuccess(result.data);
+}
+async function flatten(sharpInstance, params) {
+  const inputBg = params.background;
+  const rgbBackground = inputBg !== void 0 ? toSharpColor(inputBg) : void 0;
+  const background = rgbBackground ?? rgbBackground;
+  return sharpInstance.flatten({ background });
+}
+
+export {
+  isFlattenOperationParams,
+  flatten
+};

package/chunks/chunk-I6ZP5T5V.js

@@ -0,0 +1,10 @@
+// src/agnostic/time/wait/index.ts
+async function wait(durationMs) {
+  await new Promise((resolve) => {
+    setTimeout(() => resolve(true), durationMs);
+  });
+}
+
+export {
+  wait
+};

package/chunks/chunk-IPRWXI27.js

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

package/chunks/chunk-IRKZUMWZ.js

@@ -0,0 +1,38 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/@aws-s3/storage/file/stat/index.ts
+import {
+  HeadObjectCommand
+} from "@aws-sdk/client-s3";
+async function stat(client, bucket, key, options) {
+  const { headObjectOptions } = options ?? {};
+  try {
+    const res = await client.send(
+      new HeadObjectCommand({ Bucket: bucket, Key: key, ...headObjectOptions })
+    );
+    const stat2 = {
+      size: res.ContentLength,
+      modifiedAt: res.LastModified,
+      checksum: res.ETag?.replace(/"/g, ""),
+      contentType: res.ContentType,
+      metadata: res.Metadata,
+      storageClass: res.StorageClass,
+      raw: res
+    };
+    return makeSuccess(stat2);
+  } catch (err) {
+    const notFound = err.$metadata?.httpStatusCode === 404 || err.name === "NotFound";
+    if (notFound) return makeFailure(`Object not found: ${key}`);
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  stat
+};

package/chunks/chunk-ISJONMNA.js

@@ -0,0 +1,16 @@
+// 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;
+
+export {
+  isGcsBucket,
+  isS3ClientWithBucket,
+  isFtpClient,
+  isSftpClient
+};

package/chunks/chunk-JB27MAKY.js

@@ -0,0 +1,22 @@
+import {
+  makeFailure,
+  makeSuccess
+} from "./chunk-LUAYN7VJ.js";
+import {
+  unknownToString
+} from "./chunk-PUQUSA6S.js";
+
+// src/node/sftp/file/exists/index.ts
+async function exists(sftp, sourcePath) {
+  try {
+    const res = await sftp.exists(sourcePath);
+    const isFile = res === "-" || res === "l";
+    return makeSuccess(isFile);
+  } catch (err) {
+    return makeFailure(unknownToString(err));
+  }
+}
+
+export {
+  exists
+};

package/chunks/chunk-JZ6GM444.js

@@ -0,0 +1,43 @@
+import {
+  makeTextBlock
+} from "./chunk-H4PP6AHP.js";
+
+// src/agnostic/misc/logs/styles/index.ts
+var ansi = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  italic: "\x1B[3m",
+  underline: "\x1B[4m",
+  fg: {
+    red: "\x1B[31m",
+    green: "\x1B[32m",
+    yellow: "\x1B[33m",
+    blue: "\x1B[34m",
+    gray: "\x1B[90m",
+    whiteBright: "\x1B[97m"
+  },
+  bg: {
+    red: "\x1B[41m"
+  }
+};
+var wrap = (...ansiCodes) => (text) => `${ansiCodes.join("")}${text}${ansi.reset}`;
+var styles = {
+  regular: (text) => text,
+  light: wrap(ansi.fg.gray),
+  danger: (text) => wrap(ansi.bold, ansi.bg.red, ansi.fg.whiteBright)(makeTextBlock(`/!\\
+
+${text}
+`, 2, 6)),
+  important: wrap(ansi.bold),
+  title: (text) => `# ${wrap(ansi.bold, ansi.underline)(`${text}
+`)}`,
+  info: wrap(ansi.fg.blue),
+  success: wrap(ansi.fg.green),
+  error: wrap(ansi.fg.red),
+  warning: wrap(ansi.fg.yellow),
+  italic: wrap(ansi.italic)
+};
+
+export {
+  styles
+};