@design-edito/tools 0.1.73 → 0.2.1

package/chunks/chunk-454MZ5UE.js

@@ -1,239 +0,0 @@
-import {
-  ease
-} from "./chunk-JJWKHBXD.js";
-import {
-  clampNumber,
-  randomIntRange,
-  shuffleArray
-} from "./chunk-7DDXALPH.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
-
-// src/node/@design-edito/thumbnails/layout/index.ts
-var layout_exports = {};
-__export(layout_exports, {
-  alignBottomCenter: () => alignBottomCenter,
-  alignBottomLeft: () => alignBottomLeft,
-  alignBottomRight: () => alignBottomRight,
-  alignCenter: () => alignCenter,
-  alignLeftCenter: () => alignLeftCenter,
-  alignRightCenter: () => alignRightCenter,
-  alignTopCenter: () => alignTopCenter,
-  alignTopLeft: () => alignTopLeft,
-  alignTopRight: () => alignTopRight,
-  getContainedDimensions: () => getContainedDimensions,
-  getOffset: () => getOffset,
-  packAreasAndTiles: () => packAreasAndTiles
-});
-function getContainedDimensions(w, h, wrapperW, wrapperH, ignoreIfSmaller) {
-  if (ignoreIfSmaller && w <= wrapperW && h <= wrapperH) {
-    return { w, h };
-  }
-  const wrapperRatio = wrapperW / wrapperH;
-  const imgRatio = w / h;
-  const containRatio = imgRatio > wrapperRatio ? wrapperW / w : wrapperH / h;
-  return {
-    w: Math.round(w * containRatio),
-    h: Math.round(h * containRatio)
-  };
-}
-function packAreasAndTiles(initialShape, dimensions, tileCoverage, tileDensity, tileEasing, tileFormat) {
-  const areas = [];
-  const basePositions = {
-    top: Math.ceil(initialShape.y),
-    bottom: Math.ceil(initialShape.y + initialShape.h),
-    left: Math.ceil(initialShape.x),
-    right: Math.ceil(initialShape.x + initialShape.w)
-  };
-  for (let i = 0; i < 9; i++) {
-    if (i === 4) {
-      continue;
-    }
-    const middleColumn = i % 3 === 1;
-    const rightColumn = i % 3 === 2;
-    const topRow = i < 3;
-    const middleRow = !topRow && i < 6;
-    const bottomRow = !topRow && !middleRow;
-    areas[i] = { x: 0, y: 0, w: basePositions.left, h: basePositions.top };
-    if (middleColumn) {
-      areas[i].x = basePositions.left;
-      areas[i].w = initialShape.w;
-    }
-    if (rightColumn) {
-      areas[i].x = basePositions.right;
-    }
-    if (middleRow) {
-      areas[i].y = basePositions.top;
-      areas[i].h = initialShape.h;
-    }
-    if (bottomRow) {
-      areas[i].y = basePositions.bottom;
-      areas[i].h = dimensions.h - basePositions.bottom;
-    }
-  }
-  const filteredAreas = shuffleArray(areas.filter((area) => area.w !== 0 && area.h !== 0));
-  const subTiles = [];
-  const nbAreas = filteredAreas.length;
-  const nbAreasToCover = Math.round(nbAreas * tileCoverage / 100);
-  if (tileDensity.A.min > 1 || tileDensity.A.max > 1 || tileDensity.B.min > 1 || tileDensity.B.max > 1) {
-    filteredAreas.forEach((area, areaI) => {
-      if (areaI > nbAreasToCover) {
-        subTiles.push(area);
-        return;
-      }
-      const { nbRows, nbColumns } = getNbRowsAndColumnsForFormat(randomIntRange(tileDensity.A.min, tileDensity.A.max), randomIntRange(tileDensity.B.min, tileDensity.B.max), area, tileFormat);
-      const tiles = [];
-      for (let i = 0; i < nbRows; i++) {
-        for (let j = 0; j < nbColumns; j++) {
-          const columnI = j;
-          const rowI = i;
-          const x = Math.ceil(area.w * ease(columnI / nbColumns, tileEasing.X));
-          const y = Math.ceil(area.h * ease(rowI / nbRows, tileEasing.Y));
-          tiles.push({
-            x: area.x + x,
-            y: area.y + y
-          });
-        }
-      }
-      const nbTiles = tiles.length;
-      tiles.forEach((subTileCoord, i) => {
-        const tileNum = i + 1;
-        const nextTileX = tileNum % nbColumns > 0 ? tiles[i + 1] : null;
-        const nextTileY = i + nbColumns < nbTiles ? tiles[i + nbColumns] : null;
-        const subTileBounds = {
-          x: nextTileX ? nextTileX.x : area.x + area.w,
-          y: nextTileY ? nextTileY.y : area.y + area.h
-        };
-        subTiles.push({
-          x: subTileCoord.x,
-          y: subTileCoord.y,
-          w: subTileBounds.x - subTileCoord.x,
-          h: subTileBounds.y - subTileCoord.y
-        });
-      });
-    });
-  }
-  return (subTiles.length ? subTiles : filteredAreas).map((tile) => ({
-    w: clampNumber(tile.w, 0, dimensions.w),
-    h: clampNumber(tile.h, 0, dimensions.h),
-    x: clampNumber(tile.x, 0, dimensions.w),
-    y: clampNumber(tile.y, 0, dimensions.h)
-  })).filter((tile) => tile.w > 0 && tile.h > 0);
-}
-function getNbRowsAndColumnsForFormat(tileDensityA, tileDensityB, tileDimensions, tileFormat) {
-  switch (tileFormat) {
-    case "random":
-      const random = Math.random() > Math.random();
-      return {
-        nbRows: random ? tileDensityA : tileDensityB,
-        nbColumns: random ? tileDensityB : tileDensityA
-      };
-    case "portrait":
-      return {
-        nbRows: tileDensityA,
-        nbColumns: tileDensityB
-      };
-    case "landscape":
-      return {
-        nbRows: tileDensityB,
-        nbColumns: tileDensityA
-      };
-    default:
-      return {
-        nbRows: tileDimensions.w > tileDimensions.w ? tileDensityA : tileDensityB,
-        nbColumns: tileDimensions.w > tileDimensions.h ? tileDensityB : tileDensityA
-      };
-  }
-}
-function alignTopLeft(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalLeft(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalTop(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignTopCenter(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalCenter(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalTop(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignTopRight(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalRight(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalTop(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignLeftCenter(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalLeft(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalCenter(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignRightCenter(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalRight(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalCenter(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignCenter(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalCenter(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalCenter(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignBottomLeft(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalLeft(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalBottom(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignBottomCenter(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalCenter(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalBottom(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignBottomRight(dimensions, containedDimensions, wrapperDimensions) {
-  return {
-    x: alignHorizontalRight(dimensions, containedDimensions, wrapperDimensions),
-    y: alignVerticalBottom(dimensions, containedDimensions, wrapperDimensions)
-  };
-}
-function alignHorizontalLeft(dimensions, containedDimensions, wrapperDimensions) {
-  return getOffset(dimensions.w, containedDimensions.w);
-}
-function alignHorizontalCenter(dimensions, containedDimensions, wrapperDimensions) {
-  return getOffset(dimensions.w, wrapperDimensions.w);
-}
-function alignHorizontalRight(dimensions, containedDimensions, wrapperDimensions) {
-  return wrapperDimensions.w - (dimensions.w - getOffset(containedDimensions.w, dimensions.w));
-}
-function alignVerticalTop(dimensions, containedDimensions, wrapperDimensions) {
-  return getOffset(dimensions.h, containedDimensions.h);
-}
-function alignVerticalCenter(dimensions, containedDimensions, wrapperDimensions) {
-  return getOffset(dimensions.h, wrapperDimensions.h);
-}
-function alignVerticalBottom(dimensions, containedDimensions, wrapperDimensions) {
-  return wrapperDimensions.h - (dimensions.h - getOffset(containedDimensions.h, dimensions.h));
-}
-function getOffset(size, wrapperSize) {
-  return (wrapperSize - size) / 2;
-}
-
-export {
-  getContainedDimensions,
-  packAreasAndTiles,
-  alignTopLeft,
-  alignTopCenter,
-  alignTopRight,
-  alignLeftCenter,
-  alignRightCenter,
-  alignCenter,
-  alignBottomLeft,
-  alignBottomCenter,
-  alignBottomRight,
-  getOffset,
-  layout_exports
-};

package/chunks/chunk-45WKBXSF.js

@@ -1,39 +0,0 @@
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-NZLE2WMY.js";
-
-// src/node/sftp/file/upload/index.ts
-var upload_exports = {};
-__export(upload_exports, {
-  upload: () => upload
-});
-async function upload(fileStream, targetPath, sftp, options) {
-  const {
-    ensureDir = false,
-    overwrite = false
-  } = options ?? {};
-  try {
-    const exists = await sftp.exists(targetPath);
-    if (exists && !overwrite) return Outcome.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 Outcome.makeSuccess(true);
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return Outcome.makeFailure(errStr);
-  }
-}
-
-export {
-  upload,
-  upload_exports
-};

package/chunks/chunk-4A2IILES.js

@@ -1,16 +0,0 @@
-import {
-  OperationNames
-} from "./chunk-MOVLLUDL.js";
-import {
-  esm_default
-} from "./chunk-QPHK5QI7.js";
-
-// src/node/images/transform/brighten/index.ts
-var brightenSchema = esm_default.object({
-  name: esm_default.literal(OperationNames.Brighten),
-  params: esm_default.number().min(0)
-});
-
-export {
-  brightenSchema
-};

package/chunks/chunk-4ARTWFW5.js

@@ -1,164 +0,0 @@
-import {
-  createColorPalette
-} from "./chunk-XTOAQTLP.js";
-import {
-  createLineBackground
-} from "./chunk-GE7DNPF6.js";
-import {
-  createTileBackground
-} from "./chunk-MKHTR43Q.js";
-import {
-  getRelativePxPositionsInWrapperFor
-} from "./chunk-OCM3RLO6.js";
-import {
-  clamp
-} from "./chunk-OSAXBA7G.js";
-
-// src/node/images/transform/operations/_utils/frame/index.ts
-import sharp from "sharp";
-async function frame(imageSharp, params) {
-  const imageMetadata = await imageSharp.metadata();
-  const imageDimensions = {
-    widthPx: imageMetadata.width ?? 0,
-    heightPx: imageMetadata.height ?? 0
-  };
-  const scaledImage = scaleImageToFrame(
-    imageSharp,
-    imageDimensions,
-    params.dimensions,
-    params.imageScale
-  );
-  imageSharp = scaledImage.sharpInstance;
-  imageDimensions.widthPx = scaledImage.widthPx;
-  imageDimensions.heightPx = scaledImage.heightPx;
-  const defaultBackgroundColorCreate = getDefaultBackgroundColor(params.background);
-  const imagePositions = getRelativePxPositionsInWrapperFor(imageDimensions, params.dimensions, params.positions);
-  const backgroundOverlays = await getBackgroundOverlays(
-    {
-      sharp: imageSharp,
-      dimensions: imageDimensions
-    },
-    params.background,
-    params.dimensions,
-    {
-      x: imagePositions.x,
-      y: imagePositions.y,
-      w: imageDimensions.widthPx,
-      h: imageDimensions.heightPx
-    }
-  );
-  const composition = [
-    ...backgroundOverlays,
-    {
-      input: await imageSharp.toFormat("png").png({ quality: 100 }).toBuffer(),
-      /* Make sure we work with the best quality of our file */
-      left: imagePositions.x,
-      top: imagePositions.y
-    }
-  ];
-  const frameSharpInstance = sharp({
-    create: {
-      background: defaultBackgroundColorCreate,
-      width: params.dimensions.widthPx,
-      height: params.dimensions.heightPx,
-      channels: 4
-    }
-  }).ensureAlpha(0).composite(composition).png({ quality: 100 });
-  return frameSharpInstance;
-}
-var scaleImageToFrame = (imageSharp, imageDimensions, frameDimensions, imageScale) => {
-  const scale = {
-    xRatio: 1,
-    yRatio: 1
-  };
-  const frameZoneDimensions = {
-    widthPx: frameDimensions.widthPx,
-    heightPx: frameDimensions.heightPx
-  };
-  if (imageScale) {
-    frameZoneDimensions.widthPx = frameDimensions.widthPx * (imageScale.xRatio || 1);
-    frameZoneDimensions.heightPx = frameDimensions.heightPx * (imageScale.yRatio || 1);
-  }
-  const containedRatiosPercents = getContainedRatios(
-    imageDimensions.widthPx,
-    imageDimensions.heightPx,
-    frameZoneDimensions.widthPx,
-    frameZoneDimensions.heightPx
-  );
-  if (imageScale || !imageScale && imageDimensions.widthPx < frameDimensions.widthPx && imageDimensions.heightPx < frameDimensions.heightPx) {
-    scale.xRatio = containedRatiosPercents.xPercent;
-    scale.yRatio = containedRatiosPercents.yPercent;
-  }
-  if (scale.xRatio !== 1 || scale.yRatio !== 1) {
-    imageDimensions.widthPx = clamp(Math.round(imageDimensions.widthPx * scale.xRatio), 0, frameDimensions.widthPx);
-    imageDimensions.heightPx = clamp(Math.round(imageDimensions.heightPx * scale.yRatio), 0, frameDimensions.heightPx);
-    imageSharp = imageSharp.resize({
-      width: imageDimensions.widthPx,
-      height: imageDimensions.heightPx,
-      fit: sharp.fit.inside,
-      position: "center",
-      fastShrinkOnLoad: false
-    });
-  }
-  return {
-    sharpInstance: imageSharp,
-    widthPx: imageDimensions.widthPx,
-    heightPx: imageDimensions.heightPx
-  };
-};
-var getDefaultBackgroundColor = (background) => {
-  if (background && (typeof background === "object" && "r" in background)) {
-    return {
-      r: background.r || 255,
-      g: background.g || 255,
-      b: background.b || 255,
-      alpha: background.alpha || 0
-    };
-  }
-  return { r: 255, g: 255, b: 255, alpha: 0 };
-};
-var getBackgroundOverlays = (imageInput, background, dimensions, imageCoordinates) => {
-  const backgroundOverlays = [];
-  return new Promise(async (resolve, reject) => {
-    if (!background || typeof background !== "object" || typeof background === "object" && !("type" in background)) {
-      resolve(backgroundOverlays);
-      return;
-    }
-    const imageBuffer = await imageInput.sharp.raw().toBuffer();
-    const nbImageChannels = (await imageInput.sharp.metadata()).channels || 3;
-    const colorPalette = createColorPalette(
-      {
-        buffer: imageBuffer,
-        nbChannels: nbImageChannels,
-        dimensions: imageInput.dimensions
-      },
-      background.colorPalette
-    );
-    switch (background.type) {
-      case "line":
-        return resolve(createLineBackground(background, dimensions, colorPalette));
-      case "tile":
-        return resolve(createTileBackground(background, dimensions, imageCoordinates, colorPalette));
-      default:
-        resolve(backgroundOverlays);
-    }
-    reject(new Error("Unknown background type"));
-  });
-};
-function getContainedRatios(widthPx, heightPx, wrapperWidthPx, wrapperHeightPx, withoutReduction) {
-  if (withoutReduction && widthPx <= wrapperWidthPx && heightPx <= wrapperHeightPx) {
-    return { xPercent: 100, yPercent: 100 };
-  }
-  const wrapperRatio = wrapperWidthPx / wrapperHeightPx;
-  const imgRatio = widthPx / heightPx;
-  const containRatio = clamp(imgRatio > wrapperRatio ? wrapperWidthPx / widthPx : wrapperHeightPx / heightPx, 0, 100);
-  return {
-    xPercent: containRatio,
-    yPercent: containRatio
-  };
-}
-
-export {
-  frame,
-  getContainedRatios
-};

package/chunks/chunk-4CAHGPFA.js

@@ -1,32 +0,0 @@
-import {
-  Outcome
-} from "./chunk-JMU5PDBD.js";
-import {
-  unknownToString
-} from "./chunk-FENXVJYO.js";
-import {
-  __export
-} from "./chunk-WSFCRVEQ.js";
-
-// src/node/@google-cloud/storage/file/move/index.ts
-var move_exports = {};
-__export(move_exports, {
-  move: () => move
-});
-async function move(sourcePath, targetPath, bucket, options) {
-  const { fileOptions, copyOptions, deleteOptions } = options ?? {};
-  try {
-    const file = bucket.file(sourcePath, fileOptions);
-    await file.copy(targetPath, copyOptions);
-    await file.delete(deleteOptions);
-    return Outcome.makeSuccess(true);
-  } catch (err) {
-    const errStr = unknownToString(err);
-    return Outcome.makeFailure(errStr);
-  }
-}
-
-export {
-  move,
-  move_exports
-};

package/chunks/chunk-4HLAM4RP.js

@@ -1,191 +0,0 @@
-import {
-  Arrays
-} from "./chunk-VWLJ5IEE.js";
-import {
-  Random
-} from "./chunk-OVG5RGI3.js";
-
-// src/agnostic/misc/lorem-ipsum/index.ts
-var LoremIpsum;
-((LoremIpsum2) => {
-  LoremIpsum2.words = [
-    "a",
-    "ac",
-    "accumsan",
-    "adipiscing",
-    "aenean",
-    "aliquam",
-    "aliquet",
-    "amet",
-    "ante",
-    "arcu",
-    "at",
-    "auctor",
-    "augue",
-    "bibendum",
-    "blandit",
-    "condimentum",
-    "consectetur",
-    "consequat",
-    "convallis",
-    "cras",
-    "curabitur",
-    "cursus",
-    "dapibus",
-    "diam",
-    "dictum",
-    "dictumst",
-    "dignissim",
-    "dolor",
-    "donec",
-    "dui",
-    "duis",
-    "efficitur",
-    "egestas",
-    "eget",
-    "eleifend",
-    "elementum",
-    "elit",
-    "enim",
-    "erat",
-    "eros",
-    "est",
-    "et",
-    "eu",
-    "euismod",
-    "ex",
-    "facilisis",
-    "faucibus",
-    "felis",
-    "feugiat",
-    "finibus",
-    "fringilla",
-    "fusce",
-    "gravida",
-    "habitasse",
-    "hac",
-    "hendrerit",
-    "iaculis",
-    "id",
-    "imperdiet",
-    "in",
-    "integer",
-    "interdum",
-    "ipsum",
-    "justo",
-    "lacinia",
-    "lacus",
-    "laoreet",
-    "lectus",
-    "leo",
-    "libero",
-    "ligula",
-    "lobortis",
-    "lorem",
-    "luctus",
-    "maecenas",
-    "magna",
-    "malesuada",
-    "massa",
-    "mattis",
-    "mauris",
-    "maximus",
-    "metus",
-    "mi",
-    "molestie",
-    "mollis",
-    "morbi",
-    "nam",
-    "nec",
-    "neque",
-    "nibh",
-    "nisi",
-    "nisl",
-    "non",
-    "nulla",
-    "nullam",
-    "nunc",
-    "odio",
-    "orci",
-    "ornare",
-    "pellentesque",
-    "pharetra",
-    "phasellus",
-    "placerat",
-    "platea",
-    "porta",
-    "porttitor",
-    "posuere",
-    "praesent",
-    "pulvinar",
-    "purus",
-    "quam",
-    "quis",
-    "quisque",
-    "risus",
-    "rutrum",
-    "sagittis",
-    "sapien",
-    "sed",
-    "sem",
-    "semper",
-    "sit",
-    "sodales",
-    "sollicitudin",
-    "suscipit",
-    "suspendisse",
-    "tellus",
-    "tempor",
-    "tempus",
-    "tincidunt",
-    "tortor",
-    "tristique",
-    "turpis",
-    "ultrices",
-    "ultricies",
-    "urna",
-    "ut",
-    "vehicula",
-    "vel",
-    "velit",
-    "venenatis",
-    "vestibulum",
-    "vitae",
-    "vivamus",
-    "viverra",
-    "volutpat",
-    "vulputate"
-  ];
-  LoremIpsum2.generateSentence = (wordCount) => {
-    const resultArr = [];
-    let currentWordCound = wordCount;
-    for (let i = 0; i < currentWordCound; i++) {
-      const picked = Arrays.randomPick(LoremIpsum2.words);
-      if (typeof picked === "string") resultArr.push(picked);
-      else {
-        currentWordCound += 1;
-      }
-    }
-    const [firstWord, ...otherWords] = resultArr;
-    if (firstWord === void 0) return "";
-    const capFirstLetter = firstWord?.charAt(0).toUpperCase();
-    const restOfFirstWord = firstWord?.slice(1);
-    const sentence = [
-      `${capFirstLetter}${restOfFirstWord}`,
-      ...otherWords
-    ].join(" ");
-    return `${sentence}.`;
-  };
-  LoremIpsum2.generateSentences = (sentencesCount, maxSentenceLength = 12, minSentenceLength = 4) => {
-    const sentences = [];
-    for (let i = 0; i < sentencesCount; i++) {
-      const length = Random.randomInt(maxSentenceLength, minSentenceLength) ?? 8;
-      sentences.push((0, LoremIpsum2.generateSentence)(length));
-    }
-    return sentences;
-  };
-})(LoremIpsum || (LoremIpsum = {}));
-
-export {
-  LoremIpsum
-};