@sakitam-gis/sprite-cli 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,901 @@
+// src/sprite.ts
+import fs2 from "fs/promises";
+import path2 from "path";
+import stringify from "json-stable-stringify";
+
+// src/core/layout.ts
+import { DOMParser } from "@xmldom/xmldom";
+
+// src/core/shelf-pack.ts
+var Bin = class {
+  /**
+   * @param id      Unique id of the bin
+   * @param x       Left coordinate of the bin
+   * @param y       Top coordinate of the bin
+   * @param w       Width of the bin
+   * @param h       Height of the bin
+   * @param maxw    Max width of the bin (defaults to `w` if not provided)
+   * @param maxh    Max height of the bin (defaults to `h` if not provided)
+   */
+  constructor(id, x, y, w, h, maxw, maxh) {
+    this.id = id;
+    this.x = x;
+    this.y = y;
+    this.w = w;
+    this.h = h;
+    this.maxw = maxw || w;
+    this.maxh = maxh || h;
+    this.refcount = 0;
+  }
+};
+var Shelf = class {
+  /**
+   * @param y   Top coordinate of the new shelf
+   * @param w   Width of the new shelf
+   * @param h   Height of the new shelf
+   */
+  constructor(y, w, h) {
+    this.x = 0;
+    this.y = y;
+    this.w = this.free = w;
+    this.h = h;
+  }
+  /**
+   * 在货架上分配一个 bin
+   *
+   * @param w   Width of the bin to allocate
+   * @param h   Height of the bin to allocate
+   * @param id  Unique id of the bin to allocate
+   * @returns Bin object or null if allocation failed
+   */
+  alloc(w, h, id) {
+    if (w > this.free || h > this.h) {
+      return null;
+    }
+    const x = this.x;
+    this.x += w;
+    this.free -= w;
+    return new Bin(id, x, this.y, w, h, w, this.h);
+  }
+  /**
+   * 调整货架宽度
+   *
+   * @param w  Requested new width of the shelf
+   * @returns true
+   */
+  resize(w) {
+    this.free += w - this.w;
+    this.w = w;
+    return true;
+  }
+};
+var ShelfPack = class {
+  /**
+   * @param w        Initial width of the sprite
+   * @param h        Initial height of the sprite
+   * @param options  Configuration options
+   */
+  constructor(w = 64, h = 64, options = {}) {
+    this.w = w;
+    this.h = h;
+    this.autoResize = !!options.autoResize;
+    this.shelves = [];
+    this.freebins = [];
+    this.stats = {};
+    this.bins = {};
+    this.maxId = 0;
+  }
+  /**
+   * 批量打包多个 bins
+   *
+   * @param bins     Array of requested bins
+   * @param options  Pack options
+   * @returns Array of allocated Bins
+   *
+   * @example
+   * ```ts
+   * const bins = [
+   *   { id: 1, w: 12, h: 12 },
+   *   { id: 2, w: 12, h: 16 },
+   * ];
+   * const results = sprite.pack(bins, { inPlace: false });
+   * ```
+   */
+  pack(bins, options = {}) {
+    const binArray = [].concat(bins);
+    const results = [];
+    for (let i = 0; i < binArray.length; i++) {
+      const w = binArray[i].w || binArray[i].width;
+      const h = binArray[i].h || binArray[i].height;
+      const id = binArray[i].id;
+      if (w && h) {
+        const allocation = this.packOne(w, h, id);
+        if (!allocation) {
+          continue;
+        }
+        if (options.inPlace) {
+          binArray[i].x = allocation.x;
+          binArray[i].y = allocation.y;
+          binArray[i].id = allocation.id;
+        }
+        results.push(allocation);
+      }
+    }
+    this.shrink();
+    return results;
+  }
+  /**
+   * 打包单个 bin
+   *
+   * 每个 bin 都有唯一标识符。如果未提供 id，将自动创建一个。
+   * Bins 自动进行引用计数。
+   *
+   * @param w   Width of the bin to allocate
+   * @param h   Height of the bin to allocate
+   * @param id  Unique identifier for this bin
+   * @returns Bin object or null if allocation failed
+   *
+   * @example
+   * ```ts
+   * const bin = sprite.packOne(12, 16, 'a');
+   * ```
+   */
+  packOne(w, h, id) {
+    const best = { freebin: -1, shelf: -1, waste: Infinity };
+    let y = 0;
+    let bin;
+    let shelf;
+    let waste;
+    let i;
+    if (typeof id === "string" || typeof id === "number") {
+      bin = this.getBin(id);
+      if (bin) {
+        this.ref(bin);
+        return bin;
+      }
+      if (typeof id === "number") {
+        this.maxId = Math.max(id, this.maxId);
+      }
+    } else {
+      id = ++this.maxId;
+    }
+    for (i = 0; i < this.freebins.length; i++) {
+      bin = this.freebins[i];
+      if (h === bin.maxh && w === bin.maxw) {
+        return this.allocFreebin(i, w, h, id);
+      }
+      if (h > bin.maxh || w > bin.maxw) {
+        continue;
+      }
+      if (h <= bin.maxh && w <= bin.maxw) {
+        waste = bin.maxw * bin.maxh - w * h;
+        if (waste < best.waste) {
+          best.waste = waste;
+          best.freebin = i;
+        }
+      }
+    }
+    for (i = 0; i < this.shelves.length; i++) {
+      shelf = this.shelves[i];
+      y += shelf.h;
+      if (w > shelf.free) {
+        continue;
+      }
+      if (h === shelf.h) {
+        return this.allocShelf(i, w, h, id);
+      }
+      if (h > shelf.h) {
+        continue;
+      }
+      if (h < shelf.h) {
+        waste = (shelf.h - h) * w;
+        if (waste < best.waste) {
+          best.freebin = -1;
+          best.waste = waste;
+          best.shelf = i;
+        }
+      }
+    }
+    if (best.freebin !== -1) {
+      return this.allocFreebin(best.freebin, w, h, id);
+    }
+    if (best.shelf !== -1) {
+      return this.allocShelf(best.shelf, w, h, id);
+    }
+    if (h <= this.h - y && w <= this.w) {
+      shelf = new Shelf(y, this.w, h);
+      return this.allocShelf(this.shelves.push(shelf) - 1, w, h, id);
+    }
+    if (this.autoResize) {
+      const h1 = this.h;
+      let h2 = this.h;
+      const w1 = this.w;
+      let w2 = this.w;
+      if (w1 <= h1 || w > w1) {
+        w2 = Math.max(w, w1) * 2;
+      }
+      if (h1 < w1 || h > h1) {
+        h2 = Math.max(h, h1) * 2;
+      }
+      this.resize(w2, h2);
+      return this.packOne(w, h, id);
+    }
+    return null;
+  }
+  /**
+   * 通过重用现有 freebin 分配一个 bin
+   *
+   * @param index  Index into the `this.freebins` array
+   * @param w      Width of the bin to allocate
+   * @param h      Height of the bin to allocate
+   * @param id     Unique identifier for this bin
+   * @returns Bin object
+   */
+  allocFreebin(index, w, h, id) {
+    const bin = this.freebins.splice(index, 1)[0];
+    bin.id = id;
+    bin.w = w;
+    bin.h = h;
+    bin.refcount = 0;
+    this.bins[id] = bin;
+    this.ref(bin);
+    return bin;
+  }
+  /**
+   * 在现有货架上分配 bin
+   *
+   * @param index  Index into the `this.shelves` array
+   * @param w      Width of the bin to allocate
+   * @param h      Height of the bin to allocate
+   * @param id     Unique identifier for this bin
+   * @returns Bin object
+   */
+  allocShelf(index, w, h, id) {
+    const shelf = this.shelves[index];
+    const bin = shelf.alloc(w, h, id);
+    if (bin) {
+      this.bins[id] = bin;
+      this.ref(bin);
+    }
+    return bin;
+  }
+  /**
+   * 将 sprite 的宽度/高度缩小到最小
+   *
+   * 由于 shelf-pack 在空间不足时会先加倍宽度再加倍高度，
+   * 如果这发生在打包结束时，可能会导致较大的未使用空间
+   */
+  shrink() {
+    if (this.shelves.length > 0) {
+      let w2 = 0;
+      let h2 = 0;
+      for (let j = 0; j < this.shelves.length; j++) {
+        const shelf = this.shelves[j];
+        h2 += shelf.h;
+        w2 = Math.max(shelf.w - shelf.free, w2);
+      }
+      this.resize(w2, h2);
+    }
+  }
+  /**
+   * 根据 id 返回已打包的 bin
+   *
+   * @param id  Unique identifier for this bin
+   * @returns The requested bin, or undefined if not found
+   *
+   * @example
+   * ```ts
+   * const bin = sprite.getBin('a');
+   * ```
+   */
+  getBin(id) {
+    return this.bins[id];
+  }
+  /**
+   * 增加 bin 的引用计数并更新统计信息
+   *
+   * @param bin  Bin instance
+   * @returns New refcount of the bin
+   *
+   * @example
+   * ```ts
+   * const bin = sprite.getBin('a');
+   * if (bin) sprite.ref(bin);
+   * ```
+   */
+  ref(bin) {
+    if (++bin.refcount === 1) {
+      const h = bin.h;
+      this.stats[h] = (this.stats[h] || 0) + 1;
+    }
+    return bin.refcount;
+  }
+  /**
+   * 减少 bin 的引用计数并更新统计信息
+   * 当引用计数达到 0 时，bin 将自动标记为空闲空间
+   *
+   * @param bin  Bin instance
+   * @returns New refcount of the bin
+   *
+   * @example
+   * ```ts
+   * const bin = sprite.getBin('a');
+   * if (bin) sprite.unref(bin);
+   * ```
+   */
+  unref(bin) {
+    if (bin.refcount === 0) {
+      return 0;
+    }
+    if (--bin.refcount === 0) {
+      this.stats[bin.h]--;
+      delete this.bins[bin.id];
+      this.freebins.push(bin);
+    }
+    return bin.refcount;
+  }
+  /**
+   * 清除 sprite，重置所有内容和统计信息
+   *
+   * @example
+   * ```ts
+   * sprite.clear();
+   * ```
+   */
+  clear() {
+    this.shelves = [];
+    this.freebins = [];
+    this.stats = {};
+    this.bins = {};
+    this.maxId = 0;
+  }
+  /**
+   * 调整 sprite 尺寸
+   *
+   * @param w  Requested new sprite width
+   * @param h  Requested new sprite height
+   * @returns `true` if resize succeeded
+   *
+   * @example
+   * ```ts
+   * sprite.resize(256, 256);
+   * ```
+   */
+  resize(w, h) {
+    this.w = w;
+    this.h = h;
+    for (let i = 0; i < this.shelves.length; i++) {
+      this.shelves[i].resize(w);
+    }
+    return true;
+  }
+};
+
+// src/core/metadata.ts
+import { optimize } from "svgo";
+import computePathBounds from "svg-boundings";
+var metadataPrefix = "mapbox-";
+function strongRound(value, precision = 3) {
+  const error = +Math.pow(0.1, precision).toFixed(precision);
+  if (+value.toFixed(precision) !== value) {
+    const rounded = +value.toFixed(precision - 1);
+    value = +Math.abs(rounded - value).toFixed(precision + 1) >= error ? +value.toFixed(precision) : rounded;
+  }
+  return value;
+}
+async function extractMetadata(svg, pixelRatio = 1) {
+  const svgString = svg.toString("utf-8");
+  if (!svgString.includes("mapbox-stretch") && !svgString.includes("mapbox-text-placeholder")) {
+    return {};
+  }
+  try {
+    const optimized = optimize(svgString, {
+      plugins: [
+        {
+          name: "convertShapeToPath",
+          params: {
+            convertArcs: true
+          }
+        },
+        {
+          name: "convertTransform"
+        },
+        {
+          name: "cleanupIds",
+          params: {
+            preservePrefixes: ["mapbox-"]
+          }
+        }
+      ]
+    });
+    const { DOMParser: DOMParser2 } = await import("@xmldom/xmldom");
+    const doc = new DOMParser2().parseFromString(optimized.data, "image/svg+xml");
+    const metadata = {};
+    const paths = doc.getElementsByTagName("path");
+    for (let i = 0; i < paths.length; i++) {
+      const path3 = paths[i];
+      const id = path3.getAttribute("id");
+      const d = path3.getAttribute("d");
+      if (!id || !id.startsWith(metadataPrefix) || !d) {
+        continue;
+      }
+      try {
+        const bounds = computePathBounds.path({ d }, true);
+        if (!Number.isFinite(bounds.left) || !Number.isFinite(bounds.right) || !Number.isFinite(bounds.top) || !Number.isFinite(bounds.bottom)) {
+          continue;
+        }
+        const left = strongRound(bounds.left * pixelRatio);
+        const top = strongRound(bounds.top * pixelRatio);
+        const right = strongRound(bounds.right * pixelRatio);
+        const bottom = strongRound(bounds.bottom * pixelRatio);
+        const metadataType = id.substring(metadataPrefix.length);
+        if (metadataType.startsWith("stretch-x") || metadataType === "stretch-x") {
+          metadata.stretchX = metadata.stretchX || [];
+          metadata.stretchX.push([left, right]);
+        } else if (metadataType.startsWith("stretch-y") || metadataType === "stretch-y") {
+          metadata.stretchY = metadata.stretchY || [];
+          metadata.stretchY.push([top, bottom]);
+        } else if (metadataType === "stretch") {
+          metadata.stretchX = metadata.stretchX || [];
+          metadata.stretchX.push([left, right]);
+          metadata.stretchY = metadata.stretchY || [];
+          metadata.stretchY.push([top, bottom]);
+        } else if (metadataType === "content") {
+          metadata.content = [left, top, right, bottom];
+        } else if (metadataType === "text-placeholder") {
+          metadata.placeholder = [left, top, right, bottom];
+        }
+      } catch (err) {
+        console.warn(`Failed to compute bounds for ${id}: ${err}`);
+      }
+    }
+    if (metadata.stretchX) {
+      metadata.stretchX.sort((a, b) => a[0] - b[0]);
+    }
+    if (metadata.stretchY) {
+      metadata.stretchY.sort((a, b) => a[0] - b[0]);
+    }
+    return metadata;
+  } catch (err) {
+    console.error(`Failed to extract metadata: ${err}`);
+    return {};
+  }
+}
+function hasMetadata(svg) {
+  const svgString = svg.toString("utf-8");
+  return svgString.includes("mapbox-stretch") || svgString.includes("mapbox-text-placeholder");
+}
+
+// src/core/layout.ts
+function heightAndIdComparator(a, b) {
+  const heightDiff = b.height - a.height;
+  if (heightDiff !== 0) {
+    return heightDiff;
+  }
+  return a.id.localeCompare(b.id);
+}
+function packImages(images) {
+  const sorted = [...images].sort(heightAndIdComparator);
+  const sprite = new ShelfPack(1, 1, { autoResize: true });
+  sprite.pack(sorted, { inPlace: true });
+  const packed = sorted.map((img) => ({
+    id: img.id,
+    x: img.x,
+    y: img.y,
+    w: img.width,
+    h: img.height
+  }));
+  return {
+    packed,
+    width: sprite.w,
+    height: sprite.h
+  };
+}
+var svgDimensionsCache = /* @__PURE__ */ new Map();
+async function getImageDimensions(img, pixelRatio, useCache = true) {
+  if (img.width && img.height) {
+    return {
+      width: Math.ceil(img.width * pixelRatio),
+      height: Math.ceil(img.height * pixelRatio)
+    };
+  }
+  if (img.png) {
+    const { createCanvas, Image } = await import("canvas");
+    return new Promise((resolve, reject) => {
+      const image = new Image();
+      image.onload = () => {
+        resolve({
+          width: Math.ceil(image.width * pixelRatio),
+          height: Math.ceil(image.height * pixelRatio)
+        });
+      };
+      image.onerror = reject;
+      image.src = img.png;
+    });
+  }
+  if (img.svg) {
+    let cachedDims;
+    let cacheKey;
+    if (useCache) {
+      cacheKey = img.svg.toString("base64");
+      cachedDims = svgDimensionsCache.get(cacheKey);
+      if (cachedDims) {
+        return {
+          width: Math.ceil(cachedDims.width * pixelRatio),
+          height: Math.ceil(cachedDims.height * pixelRatio)
+        };
+      }
+    }
+    try {
+      const svgString = img.svg.toString("utf8");
+      const doc = new DOMParser().parseFromString(svgString, "image/svg+xml");
+      const svgElement = doc.documentElement;
+      const parseError = doc.getElementsByTagName("parsererror");
+      if (parseError && parseError.length > 0) {
+        throw new Error(`Failed to parse SVG for ${img.id}: Invalid XML`);
+      }
+      let width = 0;
+      let height = 0;
+      const widthAttr = svgElement.getAttribute("width");
+      const heightAttr = svgElement.getAttribute("height");
+      if (widthAttr && heightAttr) {
+        width = parseFloat(widthAttr);
+        height = parseFloat(heightAttr);
+      } else {
+        const viewBox = svgElement.getAttribute("viewBox");
+        if (viewBox) {
+          const parts = viewBox.split(/\s+/);
+          if (parts.length === 4) {
+            width = parseFloat(parts[2]);
+            height = parseFloat(parts[3]);
+          }
+        }
+      }
+      if (!width || !height) {
+        console.warn(`No dimensions found for ${img.id}, using default 24x24`);
+        width = 24;
+        height = 24;
+      }
+      if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0) {
+        throw new Error(`Invalid dimensions for ${img.id}: ${width}x${height}`);
+      }
+      if (useCache && cacheKey) {
+        svgDimensionsCache.set(cacheKey, { width, height });
+      }
+      return {
+        width: Math.ceil(width * pixelRatio),
+        height: Math.ceil(height * pixelRatio)
+      };
+    } catch (err) {
+      throw new Error(`Failed to process SVG ${img.id}: ${err}`);
+    }
+  }
+  return {
+    width: Math.ceil(24 * pixelRatio),
+    height: Math.ceil(24 * pixelRatio)
+  };
+}
+function clearDimensionsCache() {
+  svgDimensionsCache.clear();
+}
+async function generateLayout(options) {
+  const {
+    imgs,
+    pixelRatio = 1,
+    format = false,
+    extractMetadata: shouldExtractMetadata = true
+  } = options;
+  const imagesWithDims = await Promise.all(
+    imgs.map(async (img) => ({
+      id: img.id,
+      svg: img.svg,
+      png: img.png,
+      ...await getImageDimensions(img, pixelRatio)
+    }))
+  );
+  const { packed } = packImages(imagesWithDims);
+  const layout = {};
+  for (const item of packed) {
+    const originalImg = imgs.find((i) => i.id === item.id);
+    if (format) {
+      layout[item.id] = {
+        width: item.w,
+        height: item.h,
+        x: item.x,
+        y: item.y,
+        pixelRatio
+      };
+      if (shouldExtractMetadata && originalImg && originalImg.svg && hasMetadata(originalImg.svg)) {
+        try {
+          const metadata = await extractMetadata(originalImg.svg, pixelRatio);
+          Object.assign(layout[item.id], metadata);
+        } catch (err) {
+          console.warn(`Failed to extract metadata for ${item.id}: ${err}`);
+        }
+      }
+    } else {
+      const img = imagesWithDims.find((i) => i.id === item.id);
+      if (img) {
+        layout[item.id] = {
+          width: item.w,
+          height: item.h,
+          x: item.x,
+          y: item.y,
+          pixelRatio,
+          svg: img.svg,
+          png: img.png
+        };
+      }
+    }
+  }
+  return layout;
+}
+async function generateLayoutUnique(options) {
+  const { imgs, pixelRatio = 1, format = false } = options;
+  const imgMap = /* @__PURE__ */ new Map();
+  for (const img of imgs) {
+    const imgString = (img.svg || img.png)?.toString("base64");
+    if (!imgString) continue;
+    const existing = imgMap.get(imgString);
+    if (existing) {
+      existing.push(img.id);
+    } else {
+      imgMap.set(imgString, [img.id]);
+    }
+  }
+  const uniqueImgs = [];
+  const idMapping = /* @__PURE__ */ new Map();
+  for (const [imgString, ids] of imgMap.entries()) {
+    const primaryId = ids[0];
+    const buffer = Buffer.from(imgString, "base64");
+    const originalImg = imgs.find((i) => i.id === primaryId);
+    if (originalImg.svg) {
+      uniqueImgs.push({ id: primaryId, svg: buffer });
+    } else {
+      uniqueImgs.push({ id: primaryId, png: buffer });
+    }
+    for (const id of ids) {
+      idMapping.set(id, primaryId);
+    }
+  }
+  const baseLayout = await generateLayout({
+    imgs: uniqueImgs,
+    pixelRatio,
+    format: false
+  });
+  const layout = {};
+  for (const img of imgs) {
+    const primaryId = idMapping.get(img.id);
+    if (primaryId && baseLayout[primaryId]) {
+      const baseItem = baseLayout[primaryId];
+      layout[img.id] = format ? {
+        width: baseItem.width,
+        height: baseItem.height,
+        x: baseItem.x,
+        y: baseItem.y,
+        pixelRatio
+      } : baseItem;
+    }
+  }
+  return layout;
+}
+
+// src/core/image.ts
+import sharp from "sharp";
+async function renderImage(imageBuffer, isPNG, ctx, x, y, width, height, pixelRatio) {
+  const { Image } = await import("canvas");
+  return new Promise((resolve, reject) => {
+    const img = new Image();
+    img.onload = () => {
+      try {
+        ctx.drawImage(img, x, y, width, height);
+        resolve();
+      } catch (error) {
+        reject(error);
+      }
+    };
+    img.onerror = (error) => {
+      reject(new Error(`Failed to load image: ${error}`));
+    };
+    if (isPNG) {
+      img.src = imageBuffer;
+    } else {
+      const svgString = imageBuffer.toString("utf8");
+      const svgDataUrl = `data:image/svg+xml;base64,${Buffer.from(svgString).toString("base64")}`;
+      img.src = svgDataUrl;
+    }
+  });
+}
+function getCanvasDimensions(layout) {
+  let maxX = 0;
+  let maxY = 0;
+  for (const item of Object.values(layout)) {
+    maxX = Math.max(maxX, item.x + item.width);
+    maxY = Math.max(maxY, item.y + item.height);
+  }
+  return {
+    width: maxX || 1,
+    height: maxY || 1
+  };
+}
+async function generateImage(layout) {
+  const { createCanvas } = await import("canvas");
+  const layoutKeys = Object.keys(layout);
+  if (layoutKeys.length === 0) {
+    throw new Error("Cannot generate image from empty layout");
+  }
+  const { width, height } = getCanvasDimensions(layout);
+  if (width === 0 || height === 0) {
+    throw new Error("Invalid canvas dimensions: width and height must be greater than 0");
+  }
+  const canvas = createCanvas(width, height);
+  const ctx = canvas.getContext("2d");
+  ctx.clearRect(0, 0, width, height);
+  const renderPromises = [];
+  for (const [id, item] of Object.entries(layout)) {
+    const svg = item.svg;
+    const png = item.png;
+    if (!svg && !png) {
+      console.warn(`Warning: No image data for '${id}', skipping...`);
+      continue;
+    }
+    const imageBuffer = svg || png;
+    const isPNG = !!png;
+    const promise = renderImage(
+      imageBuffer,
+      isPNG,
+      ctx,
+      item.x,
+      item.y,
+      item.width,
+      item.height,
+      item.pixelRatio
+    );
+    renderPromises.push(promise);
+  }
+  await Promise.all(renderPromises);
+  return canvas.toBuffer("image/png");
+}
+async function generateOptimizedImage(layout, options = {}) {
+  const { colors = 256, quality = 80, palette = true } = options;
+  const standardPng = await generateImage(layout);
+  const optimized = await sharp(standardPng).png({
+    palette,
+    quality,
+    colors,
+    compressionLevel: 9,
+    // 最高压缩级别
+    adaptiveFiltering: true,
+    force: true
+  }).toBuffer();
+  return optimized;
+}
+
+// src/utils.ts
+import fs from "fs/promises";
+import path from "path";
+async function getFilePaths(dir) {
+  const entries = await fs.readdir(dir);
+  return entries.filter((entry) => !entry.startsWith(".") && (entry.endsWith(".svg") || entry.endsWith(".png"))).map((entry) => path.join(dir, entry));
+}
+async function loadFile(filePath) {
+  const buffer = await fs.readFile(filePath);
+  const ext = path.extname(filePath).toLowerCase();
+  const id = path.basename(filePath).replace(/\.(svg|png)$/i, "");
+  if (ext === ".svg") {
+    return { svg: buffer, id };
+  } else if (ext === ".png") {
+    return { png: buffer, id };
+  } else {
+    throw new Error(`Unsupported file format: ${ext}`);
+  }
+}
+function sortById(a, b) {
+  return b.id < a.id ? 1 : -1;
+}
+
+// src/sprite.ts
+async function ensureDir(filePath) {
+  const dir = path2.dirname(filePath);
+  try {
+    await fs2.access(dir);
+  } catch {
+    await fs2.mkdir(dir, { recursive: true });
+  }
+}
+async function saveLayout(outfile, layout, format = true) {
+  const jsonPath = `${outfile}.json`;
+  await ensureDir(jsonPath);
+  const formattedLayout = format ? stringify(layout, { space: "  " }) || "{}" : JSON.stringify(layout);
+  await fs2.writeFile(jsonPath, formattedLayout, "utf8");
+}
+async function saveImage(outfile, layout) {
+  const pngPath = `${outfile}.png`;
+  await ensureDir(pngPath);
+  const image = await generateImage(layout);
+  await fs2.writeFile(pngPath, image);
+}
+async function createLayout(buffers, ratio, format, unique) {
+  const genLayout = unique ? generateLayoutUnique : generateLayout;
+  return await genLayout({ imgs: buffers, pixelRatio: ratio, format });
+}
+async function generateSprite(options) {
+  const { output, input, ratio = 1, unique = false, format = true } = options;
+  let outfile = output;
+  if (outfile.endsWith("/")) {
+    const defaultName = ratio === 1 ? "sprite" : `sprite@${ratio}x`;
+    outfile = outfile + defaultName;
+  }
+  const filePaths = await getFilePaths(input);
+  if (filePaths.length === 0) {
+    throw new Error(`No SVG or PNG files found in directory: ${input}`);
+  }
+  const buffers = await Promise.all(filePaths.map((file) => loadFile(file)));
+  buffers.sort(sortById);
+  const layoutForJson = await createLayout(buffers, ratio, format, unique);
+  const layoutForImage = await createLayout(buffers, ratio, false, unique);
+  await Promise.all([
+    saveLayout(outfile, layoutForJson, format),
+    saveImage(outfile, layoutForImage)
+  ]);
+  return {
+    jsonPath: `${outfile}.json`,
+    pngPath: `${outfile}.png`,
+    layout: layoutForJson,
+    imageCount: buffers.length
+  };
+}
+async function generateSpriteMultiple(input, output, ratios = [1, 2], unique = false) {
+  const results = await Promise.all(
+    ratios.map((ratio) => {
+      const outputPath = ratio === 1 ? output : `${output}@${ratio}x`;
+      return generateSprite({
+        output: outputPath,
+        input,
+        ratio,
+        unique
+      });
+    })
+  );
+  return results;
+}
+async function generateSpriteFromBuffers(buffers, output, options = {}) {
+  const { ratio = 1, unique = false, format = true } = options;
+  if (buffers.length === 0) {
+    throw new Error("No image buffers provided");
+  }
+  buffers.sort(sortById);
+  let outfile = output;
+  if (outfile.endsWith("/")) {
+    const defaultName = ratio === 1 ? "sprite" : `sprite@${ratio}x`;
+    outfile = outfile + defaultName;
+  }
+  const layoutForJson = await createLayout(buffers, ratio, format, unique);
+  const layoutForImage = await createLayout(buffers, ratio, false, unique);
+  await Promise.all([
+    saveLayout(outfile, layoutForJson, format),
+    saveImage(outfile, layoutForImage)
+  ]);
+  return {
+    jsonPath: `${outfile}.json`,
+    pngPath: `${outfile}.png`,
+    layout: layoutForJson,
+    imageCount: buffers.length
+  };
+}
+export {
+  clearDimensionsCache,
+  extractMetadata,
+  generateImage,
+  generateLayout,
+  generateLayoutUnique,
+  generateOptimizedImage,
+  generateSprite,
+  generateSpriteFromBuffers,
+  generateSpriteMultiple,
+  getFilePaths,
+  hasMetadata,
+  loadFile,
+  sortById
+};
+//# sourceMappingURL=index.js.map