@design-edito/tools 0.1.64 → 0.1.65

package/chunks/chunk-H7LDIXVY.js

@@ -0,0 +1,48 @@
+import {
+  upload
+} from "./chunk-7FJKDVBE.js";
+import {
+  upload as upload2
+} from "./chunk-O7UEQQ6H.js";
+import {
+  upload as upload3
+} from "./chunk-ADTQQNIQ.js";
+import {
+  upload as upload4
+} from "./chunk-45WKBXSF.js";
+import {
+  s3IdentifierData
+} from "./chunk-MOBGB2PH.js";
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/cloud-storage/operations/upload/index.ts
+var upload_exports = {};
+__export(upload_exports, {
+  upload: () => upload5
+});
+import { Bucket } from "@google-cloud/storage";
+import { S3 } from "aws-sdk";
+import { Client as FtpClient } from "basic-ftp";
+import SftpClient from "ssh2-sftp-client";
+async function upload5(fileReadable, targetPath, endpointType, endpointIdentifier, client) {
+  if (endpointType === "gcs-bucket" /* GCS */ && client instanceof Bucket) return await upload(fileReadable, targetPath, client);
+  if (endpointType === "s3-bucket" /* S3 */ && client instanceof S3) {
+    const { bucketName } = s3IdentifierData(endpointIdentifier);
+    if (bucketName === null) return Outcome.makeFailure("Invalid S3 bucket name");
+    return await upload2(fileReadable, targetPath, bucketName, client);
+  }
+  if (endpointType === "ftp" /* FTP */ && client instanceof FtpClient) return await upload3(fileReadable, targetPath, client);
+  if (endpointType === "ftps" /* FTPS */ && client instanceof FtpClient) return await upload3(fileReadable, targetPath, client);
+  if (endpointType === "sftp" /* SFTP */ && client instanceof SftpClient) return await upload4(fileReadable, targetPath, client);
+  return Outcome.makeFailure("Invalid endpoint or client type");
+}
+
+export {
+  upload5 as upload,
+  upload_exports
+};

package/chunks/chunk-HDK7W7GS.js

@@ -0,0 +1,20 @@
+import {
+  upload_exports
+} from "./chunk-ADTQQNIQ.js";
+import {
+  download_exports
+} from "./chunk-MFWKY3DT.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/ftps/file/index.ts
+var file_exports = {};
+__export(file_exports, {
+  Download: () => download_exports,
+  Upload: () => upload_exports
+});
+
+export {
+  file_exports
+};

package/chunks/chunk-HUC2IRGW.js

@@ -0,0 +1,205 @@
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/agnostic/misc/data-size/index.ts
+var data_size_exports = {};
+__export(data_size_exports, {
+  DataSize: () => DataSize,
+  bits: () => bits,
+  bytes: () => bytes,
+  exabytes: () => exabytes,
+  exbibytes: () => exbibytes,
+  gibibytes: () => gibibytes,
+  gigabytes: () => gigabytes,
+  kibibytes: () => kibibytes,
+  kiloBytes: () => kiloBytes,
+  mebibytes: () => mebibytes,
+  megaBytes: () => megaBytes,
+  pebibytes: () => pebibytes,
+  petabytes: () => petabytes,
+  tebibytes: () => tebibytes,
+  terabytes: () => terabytes
+});
+var DataSize = class {
+  value;
+  unit;
+  constructor(value, unit) {
+    this.value = value;
+    if (unit === "b" || unit === "bit") {
+      this.unit = "bit";
+    } else if (unit === "B" || unit === "byte") {
+      this.unit = "byte";
+    } else if (unit === "KB" || unit === "kilobyte") {
+      this.unit = "kilobyte";
+    } else if (unit === "MB" || unit === "megabyte") {
+      this.unit = "megabyte";
+    } else if (unit === "GB" || unit === "gigabyte") {
+      this.unit = "gigabyte";
+    } else if (unit === "TB" || unit === "terabyte") {
+      this.unit = "terabyte";
+    } else if (unit === "PB" || unit === "petabyte") {
+      this.unit = "petabyte";
+    } else if (unit === "EB" || unit === "exabyte") {
+      this.unit = "exabyte";
+    } else if (unit === "KiB" || unit === "kibibyte") {
+      this.unit = "kibibyte";
+    } else if (unit === "MiB" || unit === "mebibyte") {
+      this.unit = "mebibyte";
+    } else if (unit === "GiB" || unit === "gibibyte") {
+      this.unit = "gibibyte";
+    } else if (unit === "TiB" || unit === "tebibyte") {
+      this.unit = "tebibyte";
+    } else if (unit === "PiB" || unit === "pebibyte") {
+      this.unit = "pebibyte";
+    } else if (unit === "EiB" || unit === "exbibyte") {
+      this.unit = "exbibyte";
+    } else {
+      this.unit = "byte";
+    }
+    this.toBits = this.toBits.bind(this);
+    this.toBytes = this.toBytes.bind(this);
+    this.toKiloBytes = this.toKiloBytes.bind(this);
+    this.toMegabytes = this.toMegabytes.bind(this);
+    this.toGigabytes = this.toGigabytes.bind(this);
+    this.toTerabytes = this.toTerabytes.bind(this);
+    this.toPetabytes = this.toPetabytes.bind(this);
+    this.toExabytes = this.toExabytes.bind(this);
+    this.toKibibytes = this.toKibibytes.bind(this);
+    this.toMebibytes = this.toMebibytes.bind(this);
+    this.toGibibytes = this.toGibibytes.bind(this);
+    this.toTebibytes = this.toTebibytes.bind(this);
+    this.toPebibytes = this.toPebibytes.bind(this);
+    this.toExbibytes = this.toExbibytes.bind(this);
+  }
+  toBits() {
+    if (this.unit === "bit") return this.value;
+    if (this.unit === "byte") return this.value * 8;
+    if (this.unit === "kilobyte") return this.value * 8 * 1e3;
+    if (this.unit === "megabyte") return this.value * 8 * 1e3 * 1e3;
+    if (this.unit === "gigabyte") return this.value * 8 * 1e3 * 1e3 * 1e3;
+    if (this.unit === "terabyte") return this.value * 8 * 1e3 * 1e3 * 1e3 * 1e3;
+    if (this.unit === "petabyte") return this.value * 8 * 1e3 * 1e3 * 1e3 * 1e3 * 1e3;
+    if (this.unit === "exabyte") return this.value * 8 * 1e3 * 1e3 * 1e3 * 1e3 * 1e3 * 1e3;
+    if (this.unit === "kibibyte") return this.value * 8 * 1024;
+    if (this.unit === "mebibyte") return this.value * 8 * 1024 * 1024;
+    if (this.unit === "gibibyte") return this.value * 8 * 1024 * 1024 * 1024;
+    if (this.unit === "tebibyte") return this.value * 8 * 1024 * 1024 * 1024 * 1024;
+    if (this.unit === "pebibyte") return this.value * 8 * 1024 * 1024 * 1024 * 1024 * 1024;
+    if (this.unit === "exbibyte") return this.value * 8 * 1024 * 1024 * 1024 * 1024 * 1024 * 1024;
+    return this.value;
+  }
+  toBytes() {
+    const bits2 = this.toBits();
+    return bits2 / 8;
+  }
+  toKiloBytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1e3;
+  }
+  toMegabytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1e3 / 1e3;
+  }
+  toGigabytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1e3 / 1e3 / 1e3;
+  }
+  toTerabytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1e3 / 1e3 / 1e3 / 1e3;
+  }
+  toPetabytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1e3 / 1e3 / 1e3 / 1e3 / 1e3;
+  }
+  toExabytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1e3 / 1e3 / 1e3 / 1e3 / 1e3 / 1e3;
+  }
+  toKibibytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1024;
+  }
+  toMebibytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1024 / 1024;
+  }
+  toGibibytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1024 / 1024 / 1024;
+  }
+  toTebibytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1024 / 1024 / 1024 / 1024;
+  }
+  toPebibytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1024 / 1024 / 1024 / 1024 / 1024;
+  }
+  toExbibytes() {
+    const bytes2 = this.toBytes();
+    return bytes2 / 1024 / 1024 / 1024 / 1024 / 1024 / 1024;
+  }
+};
+function bits(value) {
+  return bytes(value, "bit");
+}
+function bytes(value, unit) {
+  return new DataSize(value, unit);
+}
+function kiloBytes(value) {
+  return bytes(value, "kilobyte");
+}
+function megaBytes(value) {
+  return bytes(value, "megabyte");
+}
+function gigabytes(value) {
+  return bytes(value, "gigabyte");
+}
+function terabytes(value) {
+  return bytes(value, "terabyte");
+}
+function petabytes(value) {
+  return bytes(value, "petabyte");
+}
+function exabytes(value) {
+  return bytes(value, "exabyte");
+}
+function kibibytes(value) {
+  return bytes(value, "kibibyte");
+}
+function mebibytes(value) {
+  return bytes(value, "mebibyte");
+}
+function gibibytes(value) {
+  return bytes(value, "gibibyte");
+}
+function tebibytes(value) {
+  return bytes(value, "tebibyte");
+}
+function pebibytes(value) {
+  return bytes(value, "pebibyte");
+}
+function exbibytes(value) {
+  return bytes(value, "exbibyte");
+}
+
+export {
+  DataSize,
+  bits,
+  bytes,
+  kiloBytes,
+  megaBytes,
+  gigabytes,
+  terabytes,
+  petabytes,
+  exabytes,
+  kibibytes,
+  mebibytes,
+  gibibytes,
+  tebibytes,
+  pebibytes,
+  exbibytes,
+  data_size_exports
+};

package/chunks/chunk-IARWH6LC.js

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

package/chunks/chunk-IJAFLBHD.js

@@ -0,0 +1,16 @@
+import {
+  z
+} from "./chunk-XEAHMN2T.js";
+import {
+  OperationNames
+} from "./chunk-MOVLLUDL.js";
+
+// src/node/images/transform/saturate/index.ts
+var saturateSchema = z.object({
+  name: z.literal(OperationNames.Saturate),
+  params: z.number().min(0)
+});
+
+export {
+  saturateSchema
+};

package/chunks/chunk-JBSS64SA.js

@@ -0,0 +1,6 @@
+// src/node/@design-edito/thumbnails/index.ts
+var thumbnails_exports = {};
+
+export {
+  thumbnails_exports
+};

package/chunks/chunk-JBZR6R5B.js

@@ -0,0 +1,15 @@
+import {
+  z
+} from "./chunk-XEAHMN2T.js";
+
+// src/node/images/transform/_utils/color-schema/index.ts
+var colorSchema = z.object({
+  r: z.number().min(0).max(255),
+  g: z.number().min(0).max(255),
+  b: z.number().min(0).max(255),
+  alpha: z.number().min(0).max(1)
+}).or(z.string().length(7));
+
+export {
+  colorSchema
+};

package/chunks/chunk-JRYI4VBX.js

@@ -0,0 +1,22 @@
+// src/node/images/transform/operations/_utils/scale/index.ts
+import sharp from "sharp";
+async function scale(imageSharp, params) {
+  const imageMetadata = await imageSharp.metadata();
+  const imageDimensions = {
+    width: imageMetadata.width ?? 0,
+    height: imageMetadata.height ?? 0
+  };
+  const xRatio = "xRatio" in params && params.xRatio !== void 0 ? params.xRatio : 1;
+  const yRatio = "yRatio" in params && params.yRatio !== void 0 ? params.yRatio : 1;
+  const background = "background" in params && params.background !== void 0 ? params.background : { r: 0, g: 0, b: 0, alpha: 0 };
+  return imageSharp.resize({
+    width: Math.floor(imageDimensions.width * xRatio),
+    height: Math.floor(imageDimensions.width * yRatio),
+    fit: sharp.fit.contain,
+    background
+  });
+}
+
+export {
+  scale
+};

package/chunks/chunk-KFMYB672.js

@@ -0,0 +1,31 @@
+import {
+  Outcome
+} from "./chunk-JMU5PDBD.js";
+import {
+  unknownToString
+} from "./chunk-FENXVJYO.js";
+import {
+  __export
+} from "./chunk-NZLE2WMY.js";
+
+// src/node/@google-cloud/storage/file/get-metadata/index.ts
+var get_metadata_exports = {};
+__export(get_metadata_exports, {
+  getMetadata: () => getMetadata
+});
+async function getMetadata(sourcePath, bucket, options) {
+  const { fileOptions, getFileMetadataOptions } = options ?? {};
+  try {
+    const file = bucket.file(sourcePath, fileOptions);
+    const [metadata] = await file.getMetadata(getFileMetadataOptions);
+    return Outcome.makeSuccess(metadata);
+  } catch (err) {
+    const errStr = unknownToString(err);
+    return Outcome.makeFailure(errStr);
+  }
+}
+
+export {
+  getMetadata,
+  get_metadata_exports
+};