makeables 0.9.0 → 0.11.0

package/dist/chunk-6RBOBRL4.js

@@ -0,0 +1,391 @@
+import {
+  InputError,
+  effectiveRasterWidth,
+  localSubmissionDraft,
+  packSheet,
+  placeNear,
+  prepareSheetPrint,
+  readSubmission,
+  renderBadge,
+  sheetPrintPdf,
+  stickerStyles
+} from "./chunk-YB2YJCBS.js";
+import {
+  assemblePackage,
+  badgeDesignSchema,
+  createStickerSheet,
+  designManifestSchema,
+  jsonBytes,
+  kitDocumentSchema,
+  kitMemberPackage,
+  packageJson,
+  packageZip,
+  sheetSizes,
+  sheetSpec,
+  sheetTypeIds,
+  sheetTypes,
+  stickerSheetSchema
+} from "./chunk-DLTVENEP.js";
+
+// src/kit.ts
+import { mkdir, mkdtemp, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { dirname, join, relative, resolve as resolve2 } from "path";
+import { createCanvas as createCanvas2, loadImage } from "@napi-rs/canvas";
+import sharp2 from "sharp";
+
+// src/sheet.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { deflateSync } from "zlib";
+import { createCanvas } from "@napi-rs/canvas";
+import sharp from "sharp";
+async function readSheet(file) {
+  const value = JSON.parse(await readFile(resolve(file), "utf8"));
+  const parsed = stickerSheetSchema.safeParse(value);
+  if (!parsed.success)
+    throw new InputError(
+      `Invalid sheet: ${parsed.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ")}`
+    );
+  return parsed.data;
+}
+function newSheet(type, size, name) {
+  if (typeof type !== "string" || !sheetTypeIds.includes(type))
+    throw new InputError(`--type must be one of ${sheetTypeIds.join(", ")}.`);
+  const sheet = createStickerSheet(
+    type,
+    typeof name === "string" ? name : void 0
+  );
+  if (size !== void 0) {
+    if (typeof size !== "string" || !(size in sheetSizes))
+      throw new InputError(`--size must be one of ${Object.keys(sheetSizes).join(", ")}.`);
+    sheet.size = size;
+  }
+  return parse(sheet);
+}
+function parse(sheet) {
+  const parsed = stickerSheetSchema.safeParse(sheet);
+  if (!parsed.success)
+    throw new InputError(parsed.error.issues.map((issue) => issue.message).join("; "));
+  return parsed.data;
+}
+async function readSticker(source) {
+  const style = stickerStyles.find((entry) => entry.source === source);
+  if (style) return badgeDesignSchema.parse(structuredClone(style));
+  const design = badgeDesignSchema.parse(JSON.parse(await readFile(resolve(source), "utf8")));
+  if (design.product !== "sticker") throw new InputError(`${source} is not a sticker design.`);
+  return design;
+}
+var artCache = /* @__PURE__ */ new Map();
+function flatArt(design) {
+  const key = JSON.stringify(design);
+  let art = artCache.get(key);
+  if (!art) {
+    art = renderBadge(design, { face: "front", person: {} }).then(async ({ png, dimensions }) => {
+      const { data, info } = await sharp(png).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+      return {
+        width: info.width,
+        height: info.height,
+        effectiveWidth: effectiveRasterWidth(design, dimensions),
+        rgba: new Uint8ClampedArray(data.buffer, data.byteOffset, data.length)
+      };
+    });
+    artCache.set(key, art);
+  }
+  return art;
+}
+async function sheetArt(sheet) {
+  return new Map(
+    await Promise.all(
+      sheet.items.map(async (item) => [item.id, await flatArt(item.design)])
+    )
+  );
+}
+function bounds(sheet) {
+  const spec = sheetSpec(sheet);
+  return { widthMm: spec.widthMm ?? 0, heightMm: spec.heightMm ?? 0 };
+}
+async function addToSheet(sheet, source, widthMm) {
+  const type = sheetTypes[sheet.type];
+  if (type.cut === "die-cut" && sheet.items.length)
+    throw new InputError("A single sticker file holds one sticker. Start another sheet.");
+  const width = widthMm === void 0 ? type.stickerWidthMm : Number(widthMm);
+  if (!Number.isFinite(width) || width < 5 || width > 300)
+    throw new InputError("--width-mm must be a number from 5 to 300.");
+  const design = await readSticker(source);
+  const base = (design.source ?? "sticker").replace(/[^a-z0-9-]/g, "").slice(0, 40) || "sticker";
+  let id = base;
+  for (let n = 2; sheet.items.some((item2) => item2.id === id); n++) id = `${base}-${n}`;
+  const spec = sheetSpec(sheet);
+  const item = {
+    id,
+    design,
+    x: (spec.widthMm ?? width) / 2,
+    y: (spec.heightMm ?? width) / 2,
+    rotation: 0,
+    widthMm: width
+  };
+  const next = parse({ ...sheet, items: [...sheet.items, item] });
+  if (type.cut === "die-cut") return { sheet: next, item, placed: true };
+  const print = prepareSheetPrint(next, await sheetArt(next));
+  const moved = placeNear(
+    spec,
+    bounds(next),
+    next.items.map((entry) => ({ item: entry, shape: print.shapes.get(entry.id) })),
+    id,
+    [item.x, item.y]
+  );
+  if (moved) next.items[next.items.length - 1] = moved;
+  return { sheet: next, item: moved ?? item, placed: Boolean(moved) };
+}
+async function packStickerSheet(sheet) {
+  if (sheetTypes[sheet.type].cut === "die-cut") return { sheet, missing: [] };
+  const print = prepareSheetPrint(sheet, await sheetArt(sheet));
+  const packed = packSheet(
+    sheetSpec(sheet),
+    bounds(sheet),
+    sheet.items.map((item) => ({ item, shape: print.shapes.get(item.id) })),
+    sheet.hero
+  );
+  return { sheet: parse({ ...sheet, items: packed.items }), missing: packed.missing };
+}
+async function checkSheet(sheet) {
+  return prepareSheetPrint(sheet, await sheetArt(sheet));
+}
+function sheetReport(print) {
+  return {
+    printable: print.printable,
+    cutValid: print.printable,
+    qualityWarnings: print.issues.filter(({ issue }) => ["low-resolution", "material-mismatch"].includes(issue.code)).map(({ id, issue }) => ({ id, ...issue })),
+    widthMm: Number(print.widthMm.toFixed(2)),
+    heightMm: Number(print.heightMm.toFixed(2)),
+    stickers: print.items.length,
+    violations: print.violations,
+    issues: print.issues.map(({ id, issue }) => ({ id, ...issue }))
+  };
+}
+async function exportSheetPdf(sheet, print) {
+  return sheetPrintPdf(sheet, print, async (bytes) => new Uint8Array(deflateSync(bytes)));
+}
+function sheetPreviewPng(print, dpi = 150) {
+  const scale = dpi / 25.4;
+  const canvas = createCanvas(
+    Math.round(print.widthMm * scale),
+    Math.round(print.heightMm * scale)
+  );
+  const context = canvas.getContext("2d");
+  context.fillStyle = "#f4f3ef";
+  context.fillRect(0, 0, canvas.width, canvas.height);
+  for (const item of print.pdfItems) {
+    const art = createCanvas(item.art.width, item.art.height);
+    const data = art.getContext("2d").createImageData(item.art.width, item.art.height);
+    data.data.set(item.art.rgba);
+    art.getContext("2d").putImageData(data, 0, 0);
+    context.save();
+    context.translate(item.x * scale, item.y * scale);
+    context.rotate(item.rotation * Math.PI / 180);
+    context.drawImage(
+      art,
+      -item.widthMm / 2 * scale,
+      -item.heightMm / 2 * scale,
+      item.widthMm * scale,
+      item.heightMm * scale
+    );
+    context.restore();
+    context.strokeStyle = "#ff00ff";
+    context.lineWidth = Math.max(1, 0.2 * scale);
+    context.beginPath();
+    for (const loop of item.cut) {
+      for (const [i, [x, y]] of loop.entries())
+        if (i) context.lineTo(x * scale, y * scale);
+        else context.moveTo(x * scale, y * scale);
+      context.closePath();
+    }
+    context.stroke();
+  }
+  return canvas.toBuffer("image/png");
+}
+
+// src/kit.ts
+async function readKit(file) {
+  return kitDocumentSchema.parse(JSON.parse(await readFile2(resolve2(file), "utf8")));
+}
+async function addKitMember(file, source, id, kind) {
+  const kit = await readKit(file);
+  const path = resolve2(source);
+  if (kind === "items") {
+    const pkg = await readSubmission(path, false);
+    if (pkg.manifest.product === "kit") throw new InputError("Nested kits are not supported.");
+  } else await readSheet(path);
+  return kitDocumentSchema.parse({
+    ...kit,
+    [kind]: [...kit[kind], { id, file: relative(dirname(resolve2(file)), path) }]
+  });
+}
+async function kitCover(title, pieces) {
+  if (!pieces.length) throw new InputError("Add a piece before rendering the kit.");
+  const columns = Math.min(4, Math.max(2, Math.ceil(Math.sqrt(pieces.length))));
+  const width = 2e3, cell = (width - 160) / columns;
+  const height = 220 + Math.ceil(pieces.length / columns) * (cell + 64);
+  const canvas = createCanvas2(width, height);
+  const context = canvas.getContext("2d");
+  context.fillStyle = "#f4f1eb";
+  context.fillRect(0, 0, width, height);
+  context.fillStyle = "#232323";
+  context.font = "bold 56px sans-serif";
+  context.fillText(title, 80, 105, width - 160);
+  context.font = "22px sans-serif";
+  context.fillText(`${pieces.length} views \xB7 Makeables`, 80, 151);
+  for (const [index, piece] of pieces.entries()) {
+    const bytes = Buffer.from(piece.bytes);
+    const isSvg = bytes.subarray(0, 200).toString("utf8").includes("<svg") || bytes.subarray(0, 20).toString("utf8").includes("<?xml");
+    const image = await loadImage(isSvg ? await sharp2(bytes).png().toBuffer() : bytes);
+    const x = 80 + index % columns * cell;
+    const y = 195 + Math.floor(index / columns) * (cell + 64);
+    const scale = Math.min((cell - 54) / image.width, (cell - 54) / image.height);
+    const w = image.width * scale, h = image.height * scale;
+    context.save();
+    context.translate(x + cell / 2, y + cell / 2);
+    context.rotate((index % 3 - 1) * 0.035);
+    context.shadowColor = "#22222225";
+    context.shadowBlur = 18;
+    context.shadowOffsetY = 9;
+    context.drawImage(image, -w / 2, -h / 2, w, h);
+    context.restore();
+    context.font = "21px sans-serif";
+    context.textAlign = "center";
+    context.fillText(piece.name, x + cell / 2, y + cell + 24, cell - 28);
+    context.textAlign = "left";
+  }
+  return new Uint8Array(canvas.toBuffer("image/png"));
+}
+async function prepareKit(file) {
+  const kit = await readKit(file);
+  if (!kit.items.length) throw new InputError("Add at least one piece to the kit.");
+  const files = {};
+  const mime = {};
+  const items = [];
+  const views = [];
+  for (const item of kit.items) {
+    const pkg = await readSubmission(resolve2(dirname(resolve2(file)), item.file), false);
+    if (pkg.manifest.product === "kit") throw new InputError("Nested kits are not supported.");
+    const manifest = designManifestSchema.parse(pkg.manifest);
+    items.push({ id: item.id, manifest });
+    for (const entry of manifest.files) {
+      const path = `items/${item.id}/${entry.path}`;
+      files[path] = pkg.files[entry.path];
+      mime[path] = entry.mime;
+    }
+    views.push({ name: manifest.title, bytes: pkg.files[manifest.front] });
+    if (manifest.back)
+      views.push({ name: `${manifest.title} \xB7 back`, bytes: pkg.files[manifest.back] });
+  }
+  const sheets = [];
+  for (const entry of kit.sheets) {
+    const sheet = await readSheet(resolve2(dirname(resolve2(file)), entry.file));
+    for (const item of sheet.items) {
+      const draft = await localSubmissionDraft(item.design);
+      for (const [id, path] of Object.entries(draft.assets)) {
+        const previous = item.design.assets?.[id];
+        item.design.assets = {
+          ...item.design.assets,
+          [id]: {
+            source: "image",
+            name: previous?.name ?? id,
+            data: `data:${draft.mime[path]};base64,${Buffer.from(draft.files[path]).toString("base64")}`,
+            ...previous && "credit" in previous ? { credit: previous.credit } : {},
+            ...previous?.source === "image" && previous.sourcePixels ? { sourcePixels: previous.sourcePixels } : {}
+          }
+        };
+      }
+    }
+    stickerSheetSchema.parse(sheet);
+    const print = await checkSheet(sheet);
+    if (!print.printable)
+      throw new InputError(
+        `Sheet ${entry.id} is not printable: ${JSON.stringify(sheetReport(print))}`
+      );
+    const base = `sheets/${entry.id}`;
+    const document = `${base}.json`, preview = `${base}.png`, pdf = `${base}.pdf`;
+    files[document] = jsonBytes(sheet);
+    mime[document] = "application/json";
+    files[preview] = sheetPreviewPng(print);
+    mime[preview] = "image/png";
+    files[pdf] = await exportSheetPdf(sheet, print);
+    mime[pdf] = "application/pdf";
+    sheets.push({ id: entry.id, document, preview, pdf });
+    views.push({ name: sheet.name, bytes: files[preview] });
+  }
+  files["cover.png"] = await kitCover(kit.name, views);
+  mime["cover.png"] = "image/png";
+  return assemblePackage(
+    {
+      product: "kit",
+      title: kit.name,
+      front: "cover.png",
+      assets: {},
+      items,
+      sheets
+    },
+    files,
+    mime
+  );
+}
+async function exportKit(file) {
+  const pkg = await readSubmission(file);
+  if (pkg.manifest.product !== "kit") throw new InputError("Choose a kit document or package.");
+  return { pkg, bytes: await packageZip(pkg) };
+}
+async function importKit(file, out) {
+  const pkg = await readSubmission(file);
+  if (pkg.manifest.product !== "kit") throw new InputError("Choose a kit package.");
+  const target = resolve2(out);
+  const temporary = await mkdtemp(join(dirname(target), ".makeables-kit-"));
+  try {
+    const kit = {
+      format: "makeables-kit",
+      version: 1,
+      name: pkg.manifest.title,
+      items: [],
+      sheets: []
+    };
+    await mkdir(join(temporary, "items"));
+    await mkdir(join(temporary, "sheets"));
+    for (const item of pkg.manifest.items) {
+      const path = `items/${item.id}.makeables.json`;
+      await writeFile(
+        join(temporary, path),
+        JSON.stringify(packageJson(kitMemberPackage(pkg, item.id)))
+      );
+      kit.items.push({ id: item.id, file: path });
+    }
+    for (const sheet of pkg.manifest.sheets) {
+      const path = `sheets/${sheet.id}.json`;
+      await writeFile(join(temporary, path), pkg.files[sheet.document]);
+      kit.sheets.push({ id: sheet.id, file: path });
+    }
+    await writeFile(join(temporary, "kit.json"), JSON.stringify(kit, null, 2));
+    await mkdir(target);
+    await rename(temporary, target);
+    return { path: join(target, "kit.json"), items: kit.items.length, sheets: kit.sheets.length };
+  } catch (error) {
+    await rm(temporary, { recursive: true, force: true });
+    throw error;
+  }
+}
+
+export {
+  readSheet,
+  newSheet,
+  addToSheet,
+  packStickerSheet,
+  checkSheet,
+  sheetReport,
+  exportSheetPdf,
+  sheetPreviewPng,
+  readKit,
+  addKitMember,
+  kitCover,
+  prepareKit,
+  exportKit,
+  importKit
+};