@dloizides/poster-render 0.0.0-stage → 0.2.0

package/dist/index.mjs

@@ -0,0 +1,821 @@
+// src/enums/BackgroundStyle.ts
+var BackgroundStyle = /* @__PURE__ */ ((BackgroundStyle2) => {
+  BackgroundStyle2["Solid"] = "solid";
+  BackgroundStyle2["Tint"] = "tint";
+  return BackgroundStyle2;
+})(BackgroundStyle || {});
+
+// src/enums/FontSetId.ts
+var FontSetId = /* @__PURE__ */ ((FontSetId2) => {
+  FontSetId2["Classic"] = "classic";
+  FontSetId2["Modern"] = "modern";
+  FontSetId2["Elegant"] = "elegant";
+  return FontSetId2;
+})(FontSetId || {});
+
+// src/enums/FormatId.ts
+var FormatId = /* @__PURE__ */ ((FormatId2) => {
+  FormatId2["Story"] = "story";
+  FormatId2["Post"] = "post";
+  FormatId2["Square"] = "square";
+  FormatId2["Phone"] = "phone";
+  FormatId2["Desktop"] = "desktop";
+  return FormatId2;
+})(FormatId || {});
+
+// src/enums/LayoutId.ts
+var LayoutId = /* @__PURE__ */ ((LayoutId2) => {
+  LayoutId2["PictureRight"] = "picture-right";
+  LayoutId2["PictureLeft"] = "picture-left";
+  LayoutId2["PictureBottom"] = "picture-bottom";
+  LayoutId2["List"] = "list";
+  LayoutId2["Arch"] = "arch";
+  LayoutId2["PhoneClockSafe"] = "phone-clock-safe";
+  LayoutId2["PhoneArch"] = "phone-arch";
+  LayoutId2["DesktopSafe"] = "desktop-safe";
+  LayoutId2["DesktopArch"] = "desktop-arch";
+  return LayoutId2;
+})(LayoutId || {});
+
+// src/enums/PaletteId.ts
+var PaletteId = /* @__PURE__ */ ((PaletteId2) => {
+  PaletteId2["Sand"] = "sand";
+  PaletteId2["Night"] = "night";
+  PaletteId2["Sea"] = "sea";
+  PaletteId2["Rose"] = "rose";
+  return PaletteId2;
+})(PaletteId || {});
+
+// src/enums/PictureAnchor.ts
+var PictureAnchor = /* @__PURE__ */ ((PictureAnchor2) => {
+  PictureAnchor2["Top"] = "top";
+  PictureAnchor2["Center"] = "center";
+  PictureAnchor2["Bottom"] = "bottom";
+  return PictureAnchor2;
+})(PictureAnchor || {});
+
+// src/formats.ts
+var FORMAT_SIZES = {
+  ["story" /* Story */]: { width: 1080, height: 1920 },
+  ["post" /* Post */]: { width: 1080, height: 1350 },
+  ["square" /* Square */]: { width: 1080, height: 1080 },
+  ["phone" /* Phone */]: { width: 1170, height: 2532 },
+  ["desktop" /* Desktop */]: { width: 2560, height: 1440 }
+};
+
+// src/palettes.ts
+var PALETTES = {
+  ["sand" /* Sand */]: { background: "#f5f4f2", tint: "#ece8e3", title: "#958a80", accent: "#e9b47f", ink: "#5f564f", soft: "#b3a89e", card: "#ffffff", arch: "#ede8e2" },
+  ["night" /* Night */]: { background: "#1c1a17", tint: "#25221e", title: "#e8dccb", accent: "#e9b47f", ink: "#f4efe8", soft: "#9c9284", card: "#2c2824", arch: "#25221f" },
+  ["sea" /* Sea */]: { background: "#eef4f3", tint: "#e1ecea", title: "#4f7d7a", accent: "#e07a5f", ink: "#2f3e46", soft: "#8aa3a1", card: "#ffffff", arch: "#e4ecea" },
+  ["rose" /* Rose */]: { background: "#f8efec", tint: "#f1e2dd", title: "#9b6b63", accent: "#c9846f", ink: "#4a3934", soft: "#b39a92", card: "#ffffff", arch: "#f1e5e1" }
+};
+
+// src/fontSets.ts
+var FONT_SETS = {
+  ["classic" /* Classic */]: { display: '"Oswald", "Arial Narrow", sans-serif', script: '"Sacramento", cursive', body: '"Fredoka", sans-serif' },
+  ["modern" /* Modern */]: { display: '"Bebas Neue", "Arial Narrow", sans-serif', script: '"Great Vibes", cursive', body: '"Montserrat", sans-serif' },
+  ["elegant" /* Elegant */]: { display: '"Playfair Display", serif', script: '"Allura", cursive', body: '"Lato", sans-serif' }
+};
+
+// src/schema/flierDocSchema.ts
+var SHORT = 60;
+var LINE = 120;
+var MAX_ROWS = 6;
+var MAX_ITEMS = 8;
+var MAX_PRICES = 4;
+var MAX_VENUE = 3;
+var MIN_SCALE = 0.3;
+var text = (maxLength) => ({ type: "string", minLength: 1, maxLength });
+var scheduleRow = {
+  type: "object",
+  required: ["label", "time"],
+  additionalProperties: false,
+  properties: { label: text(SHORT), time: text(SHORT) }
+};
+var scheduleList = { type: "array", items: scheduleRow, minItems: 1, maxItems: MAX_ROWS };
+var blocks = {
+  type: "object",
+  required: ["title"],
+  additionalProperties: false,
+  properties: {
+    title: text(SHORT),
+    titleBottom: text(SHORT),
+    script: text(SHORT),
+    venue: { type: "array", items: text(SHORT), minItems: 1, maxItems: MAX_VENUE },
+    schedule: scheduleList,
+    prices: {
+      type: "array",
+      minItems: 1,
+      maxItems: MAX_PRICES,
+      items: {
+        type: "object",
+        required: ["amount", "label"],
+        additionalProperties: false,
+        properties: { amount: text(SHORT), label: text(SHORT) }
+      }
+    },
+    includes: {
+      type: "object",
+      required: ["heading", "items"],
+      additionalProperties: false,
+      properties: { heading: text(SHORT), items: { type: "array", items: text(LINE), minItems: 1, maxItems: MAX_ROWS } }
+    },
+    footer: text(LINE)
+  }
+};
+var flierDocSchema = {
+  $schema: "https://json-schema.org/draft/2020-12/schema",
+  $id: "https://dloizides.com/schemas/flier-doc-v1.json",
+  title: "FlierDoc",
+  description: "One poster or wallpaper: format, layout, palette, fonts, picture slot and text blocks.",
+  type: "object",
+  required: ["version", "format", "layout", "palette", "fonts", "background", "blocks"],
+  additionalProperties: false,
+  properties: {
+    version: { const: 1 },
+    format: { type: "string", enum: Object.values(FormatId) },
+    layout: { type: "string", enum: Object.values(LayoutId) },
+    palette: { type: "string", enum: Object.values(PaletteId) },
+    fonts: { type: "string", enum: Object.values(FontSetId) },
+    background: { type: "string", enum: Object.values(BackgroundStyle) },
+    picture: {
+      type: "object",
+      required: ["imageId", "anchor", "scale"],
+      additionalProperties: false,
+      properties: {
+        imageId: text(SHORT),
+        anchor: { type: "string", enum: Object.values(PictureAnchor) },
+        scale: { type: "number", minimum: MIN_SCALE, maximum: 1 }
+      }
+    },
+    logo: { type: "object", required: ["imageId"], additionalProperties: false, properties: { imageId: text(SHORT) } },
+    blocks,
+    items: {
+      type: "array",
+      minItems: 1,
+      maxItems: MAX_ITEMS,
+      items: {
+        type: "object",
+        required: ["date", "schedule"],
+        additionalProperties: false,
+        properties: { date: text(SHORT), schedule: scheduleList, price: text(SHORT) }
+      }
+    }
+  }
+};
+
+// src/schema/validate.ts
+var typeName = (v) => {
+  if (v === null) {
+    return "null";
+  }
+  return Array.isArray(v) ? "array" : typeof v;
+};
+var join = (path, key) => path === "" ? key : `${path}.${key}`;
+var show = (v) => JSON.stringify(v) ?? typeName(v);
+var ARTICLE = { object: "an object", array: "an array", string: "a string", number: "a number", integer: "an integer" };
+function matchesType(schema, value) {
+  switch (schema.type) {
+    case void 0:
+      return true;
+    case "integer":
+      return Number.isInteger(value);
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    default:
+      return typeName(value) === schema.type;
+  }
+}
+function checkString(schema, value, path, errors) {
+  if (schema.minLength !== void 0 && value.trim().length < schema.minLength) {
+    errors.push(`${path}: must not be empty`);
+  }
+  if (schema.maxLength !== void 0 && value.length > schema.maxLength) {
+    errors.push(`${path}: must be at most ${schema.maxLength} characters (got ${value.length})`);
+  }
+}
+function checkNumber(schema, value, path, errors) {
+  if (schema.minimum !== void 0 && value < schema.minimum) {
+    errors.push(`${path}: must be at least ${schema.minimum} (got ${value})`);
+  }
+  if (schema.maximum !== void 0 && value > schema.maximum) {
+    errors.push(`${path}: must be at most ${schema.maximum} (got ${value})`);
+  }
+}
+function checkArray(schema, value, path, errors) {
+  if (schema.minItems !== void 0 && value.length < schema.minItems) {
+    errors.push(`${path}: must have at least ${schema.minItems} entries (got ${value.length})`);
+  }
+  if (schema.maxItems !== void 0 && value.length > schema.maxItems) {
+    errors.push(`${path}: must have at most ${schema.maxItems} entries (got ${value.length})`);
+    return;
+  }
+  const itemSchema = schema.items;
+  if (itemSchema) {
+    value.forEach((item, i) => validateAgainst(itemSchema, item, `${path}[${i}]`, errors));
+  }
+}
+function checkObject(schema, value, path, errors) {
+  const props = schema.properties ?? {};
+  for (const key of schema.required ?? []) {
+    if (value[key] === void 0) {
+      errors.push(`${join(path, key)}: is required`);
+    }
+  }
+  for (const [key, child] of Object.entries(value)) {
+    const childSchema = props[key];
+    if (childSchema === void 0) {
+      if (schema.additionalProperties === false) {
+        errors.push(`${join(path, key)}: is not allowed`);
+      }
+    } else if (child !== void 0) {
+      validateAgainst(childSchema, child, join(path, key), errors);
+    }
+  }
+}
+function validateAgainst(schema, value, path, errors) {
+  if (schema.const !== void 0) {
+    if (value !== schema.const) {
+      errors.push(`${path}: must be ${schema.const} (got ${show(value)})`);
+    }
+    return;
+  }
+  if (!matchesType(schema, value)) {
+    errors.push(`${path}: must be ${ARTICLE[schema.type ?? "object"]} (got ${typeName(value)})`);
+    return;
+  }
+  if (schema.enum && !schema.enum.includes(value)) {
+    errors.push(`${path}: must be one of ${schema.enum.join(", ")} (got ${show(value)})`);
+    return;
+  }
+  if (typeof value === "string") {
+    checkString(schema, value, path, errors);
+  } else if (typeof value === "number") {
+    checkNumber(schema, value, path, errors);
+  } else if (Array.isArray(value)) {
+    checkArray(schema, value, path, errors);
+  } else if (typeName(value) === "object") {
+    checkObject(schema, value, path, errors);
+  }
+}
+
+// src/schema/validateFlierDoc.ts
+var FlierDocError = class extends Error {
+  constructor(errors) {
+    super(`Invalid flier: ${errors.join("; ")}`);
+    this.name = "FlierDocError";
+    this.errors = errors;
+  }
+};
+function validateFlierDoc(input) {
+  if (typeName(input) !== "object") {
+    return { ok: false, errors: ["doc: must be an object"] };
+  }
+  const errors = [];
+  validateAgainst(flierDocSchema, input, "", errors);
+  const doc = input;
+  if (doc.layout === "list" /* List */ && (doc.items === void 0 || doc.items.length === 0)) {
+    errors.push('items: layout "list" needs at least one item');
+  }
+  return errors.length === 0 ? { ok: true, doc } : { ok: false, errors };
+}
+function missingAssets(doc, assets) {
+  const errors = [];
+  if (doc.picture && assets[doc.picture.imageId] === void 0) {
+    errors.push(`picture.imageId: no asset named "${doc.picture.imageId}"`);
+  }
+  if (doc.logo && assets[doc.logo.imageId] === void 0) {
+    errors.push(`logo.imageId: no asset named "${doc.logo.imageId}"`);
+  }
+  return errors;
+}
+
+// src/layout/blockGroups.ts
+var BOLD = 700;
+var SEMI = 600;
+var MEDIUM = 500;
+var SCRIPT = 400;
+var makers = (p, u) => ({
+  display: (text2, size) => ({ text: text2, role: "display", weight: BOLD, size: size * u, color: p.title }),
+  venue: (text2, size) => ({ text: text2, role: "display", weight: MEDIUM, size: size * u, color: p.ink }),
+  script: (text2, size) => ({ text: text2, role: "script", weight: SCRIPT, size: size * u, color: p.accent }),
+  strong: (text2, size) => ({ text: text2, role: "body", weight: BOLD, size: size * u, color: p.ink }),
+  accent: (text2, size) => ({ text: text2, role: "body", weight: SEMI, size: size * u, color: p.accent }),
+  item: (text2, size) => ({ text: text2, role: "body", weight: SEMI, size: size * u, color: p.ink, bullet: p.accent }),
+  soft: (text2, size) => ({ text: text2, role: "body", weight: MEDIUM, size: size * u, color: p.soft })
+});
+function headerGroups(doc, p, u) {
+  const l = makers(p, u);
+  const b = doc.blocks;
+  const lines = [l.display?.(b.title, 250), b.script ? l.script?.(b.script, 120) : void 0, b.titleBottom ? l.display?.(b.titleBottom, 250) : void 0];
+  return [{ lines: lines.filter((x) => x !== void 0), gapAfter: 0 }];
+}
+function itemGroup(item, l, u) {
+  const lines = [l.script?.(item.date, 96)];
+  item.schedule.forEach((row) => lines.push(l.strong?.(`${row.label}  ${row.time}`, 42)));
+  if (item.price) {
+    lines.push(l.accent?.(item.price, 42));
+  }
+  return { lines, gapAfter: 26 * u };
+}
+function eventGroups(doc, l, u, withPrices) {
+  const b = doc.blocks;
+  const groups = [];
+  b.schedule?.forEach((row) => groups.push({ lines: [l.strong?.(row.label, 66), l.accent?.(row.time, 60)], gapAfter: 30 * u }));
+  (withPrices ? b.prices : void 0)?.forEach((row) => groups.push({ lines: [l.strong?.(row.amount, 66), l.accent?.(row.label, 52)], gapAfter: 30 * u }));
+  return groups;
+}
+function listGroups(doc, l, u) {
+  const groups = (doc.items ?? []).map((item) => itemGroup(item, l, u));
+  const prices = doc.blocks.prices?.map((row) => l.strong?.(`${row.amount} ${row.label}`, 58)) ?? [];
+  if (prices.length > 0) {
+    groups.push({ lines: prices, gapAfter: 30 * u });
+  }
+  return groups;
+}
+function flankPriceGroups(doc, p, u) {
+  const l = makers(p, u);
+  return (doc.blocks.prices ?? []).map((row) => ({ lines: [l.strong?.(row.amount, 110), l.accent?.(row.label, 48)], gapAfter: 30 * u }));
+}
+function bodyGroups(doc, p, u, withPrices = true) {
+  const l = makers(p, u);
+  const b = doc.blocks;
+  const groups = [];
+  const isList = doc.layout === "list" /* List */;
+  if (b.venue) {
+    groups.push({ lines: b.venue.map((v) => l.venue?.(v, isList ? 48 : 58)), gapAfter: 40 * u, rule: { color: p.accent, height: 8 * u } });
+  }
+  groups.push(...isList ? listGroups(doc, l, u) : eventGroups(doc, l, u, withPrices));
+  if (b.includes) {
+    const lines = [l.accent?.(b.includes.heading, 38), ...b.includes.items.map((i) => l.item?.(i, 38))];
+    groups.push({ lines, gapAfter: 24 * u, card: { color: p.card, pad: 28 * u }, uniform: true });
+  }
+  if (b.footer) {
+    groups.push({ lines: [l.soft?.(b.footer, 34)], gapAfter: 0 });
+  }
+  return groups;
+}
+
+// src/layout/layoutSpecs.ts
+var flanksBeside = (pic, top, bottom2, m) => [
+  [m, top, pic[0] - 2 * m, bottom2 - top],
+  [pic[0] + pic[2] + m, top, 1 - pic[0] - pic[2] - 2 * m, bottom2 - top]
+];
+var ARCH_PIC = [0.22, 0.42, 0.56, 0.58];
+var PHONE_ARCH_PIC = [0.2, 0.6, 0.6, 0.4];
+var DESK_ARCH_PIC = [0.355, 0.07, 0.32, 0.93];
+var ARCH_LANDSCAPE = {
+  header: [0.04, 0.06, 0.3, 0.5],
+  body: [0.04, 0.58, 0.3, 0.36],
+  picture: [0.36, 0.08, 0.3, 0.92],
+  alignX: 0.5,
+  flanks: [[0.68, 0.08, 0.28, 0.42], [0.68, 0.52, 0.28, 0.42]],
+  arch: 0.06
+};
+var LAYOUT_SPECS = {
+  ["arch" /* Arch */]: {
+    portrait: { header: [0.045, 0.025, 0.91, 0.18], body: [0.045, 0.215, 0.91, 0.19], picture: ARCH_PIC, alignX: 0.5, flanks: flanksBeside(ARCH_PIC, 0.44, 0.97, 0.03), arch: 0.04 },
+    landscape: ARCH_LANDSCAPE
+  },
+  ["phone-clock-safe" /* PhoneClockSafe */]: {
+    portrait: { header: [0.045, 0.28, 0.91, 0.2], body: [0.045, 0.5, 0.42, 0.44], picture: [0.48, 0.5, 0.52, 0.5], alignX: 1 },
+    landscape: { header: [0.04, 0.2, 0.52, 0.3], body: [0.04, 0.52, 0.52, 0.42], picture: [0.6, 0.12, 0.4, 0.88], alignX: 1 }
+  },
+  ["phone-arch" /* PhoneArch */]: {
+    portrait: { header: [0.045, 0.3, 0.91, 0.13], body: [0.045, 0.44, 0.91, 0.14], picture: PHONE_ARCH_PIC, alignX: 0.5, flanks: flanksBeside(PHONE_ARCH_PIC, 0.63, 0.94, 0.03), arch: 0.08 },
+    landscape: { ...ARCH_LANDSCAPE, header: [0.04, 0.16, 0.3, 0.42], picture: [0.36, 0.16, 0.3, 0.84] }
+  },
+  ["desktop-safe" /* DesktopSafe */]: {
+    portrait: { header: [0.08, 0.06, 0.84, 0.24], body: [0.08, 0.31, 0.46, 0.58], picture: [0.56, 0.36, 0.44, 0.64], alignX: 1 },
+    landscape: { header: [0.0625, 0.05, 0.58, 0.44], body: [0.0625, 0.5, 0.58, 0.38], picture: [0.67, 0.0972, 0.29, 0.9028], alignX: 1 }
+  },
+  ["desktop-arch" /* DesktopArch */]: {
+    portrait: { header: [0.08, 0.06, 0.84, 0.2], body: [0.08, 0.27, 0.84, 0.2], picture: [0.14, 0.48, 0.72, 0.52], alignX: 0.5, arch: 0.05 },
+    landscape: { header: [0.07, 0.3, 0.26, 0.45], body: [0.7, 0.25, 0.27, 0.65], picture: DESK_ARCH_PIC, alignX: 0.5, logo: [0.88, 0.04, 0.09, 0.14], arch: 0.05 }
+  }
+};
+var r = Math.round;
+var toRect = (f, w, h) => {
+  const x = r(f[0] * w);
+  const y = r(f[1] * h);
+  return { x, y, w: r((f[0] + f[2]) * w) - x, h: r((f[1] + f[3]) * h) - y };
+};
+
+// src/layout/geometry.ts
+var MARGIN = 0.045;
+var HEADER_PORTRAIT = 0.3;
+var HEADER_LANDSCAPE = 0.36;
+var BOTTOM_HEADER = 0.2;
+var BOTTOM_PICTURE = 0.52;
+var PICTURE_SIDE = {
+  ["picture-right" /* PictureRight */]: [0.6, 0.42],
+  ["picture-left" /* PictureLeft */]: [0.6, 0.42],
+  ["list" /* List */]: [0.5, 0.36]
+};
+var ANCHOR_Y = { ["top" /* Top */]: 0, ["center" /* Center */]: 0.5, ["bottom" /* Bottom */]: 1 };
+var r2 = Math.round;
+function side(w, h, fraction) {
+  const m = r2(Math.min(w, h) * MARGIN);
+  if (h >= w) {
+    const split2 = r2(w * (1 - fraction[0]));
+    const top2 = r2(h * HEADER_PORTRAIT);
+    return {
+      header: { x: m, y: m, w: w - 2 * m, h: top2 - 2 * m },
+      picture: { x: split2, y: top2, w: w - split2, h: h - top2 },
+      body: { x: m, y: top2, w: split2 - 2 * m, h: h - top2 - m },
+      alignX: 1
+    };
+  }
+  const split = r2(w * (1 - fraction[1]));
+  const top = r2(h * HEADER_LANDSCAPE);
+  return {
+    header: { x: m, y: m, w: split - 2 * m, h: top - m },
+    picture: { x: split, y: 0, w: w - split, h },
+    body: { x: m, y: top + r2(m / 2), w: split - 2 * m, h: h - top - r2(m / 2) - m },
+    alignX: 1
+  };
+}
+function bottom(w, h) {
+  const m = r2(Math.min(w, h) * MARGIN);
+  const top = r2(h * BOTTOM_HEADER);
+  const pic = r2(h * BOTTOM_PICTURE);
+  return {
+    header: { x: m, y: m, w: w - 2 * m, h: top - 2 * m },
+    body: { x: m, y: top, w: w - 2 * m, h: pic - top - m },
+    picture: { x: 0, y: pic, w, h: h - pic },
+    alignX: 0.5
+  };
+}
+function fromSpec(spec, w, h) {
+  return {
+    header: toRect(spec.header, w, h),
+    body: toRect(spec.body, w, h),
+    picture: toRect(spec.picture, w, h),
+    alignX: spec.alignX,
+    flanks: spec.flanks?.map((f) => toRect(f, w, h)),
+    logo: spec.logo ? toRect(spec.logo, w, h) : void 0,
+    arch: spec.arch
+  };
+}
+var mirror = (rect, w) => ({ ...rect, x: w - rect.x - rect.w });
+function geometry(layout, w, h) {
+  const oriented = LAYOUT_SPECS[layout];
+  if (oriented) {
+    return fromSpec(h >= w ? oriented.portrait : oriented.landscape, w, h);
+  }
+  if (layout === "picture-bottom" /* PictureBottom */) {
+    return bottom(w, h);
+  }
+  const g = side(w, h, PICTURE_SIDE[layout] ?? [0.6, 0.42]);
+  if (layout !== "picture-left" /* PictureLeft */) {
+    return g;
+  }
+  return { header: mirror(g.header, w), body: mirror(g.body, w), picture: mirror(g.picture, w), alignX: 1 - g.alignX };
+}
+function placeContain(image, region, anchor, alignX, scale) {
+  const s = Math.min(region.w / image.width, region.h / image.height) * scale;
+  const w = Math.floor(image.width * s);
+  const h = Math.floor(image.height * s);
+  return {
+    x: region.x + Math.floor((region.w - w) * alignX),
+    y: region.y + Math.floor((region.h - h) * ANCHOR_Y[anchor]),
+    w,
+    h
+  };
+}
+
+// src/layout/textFlow.ts
+var LINE_HEIGHT = 1.2;
+var BULLET_INDENT = 1.1;
+var BULLET_RADIUS = 0.2;
+var RULE_GAP = 2.5;
+var RULE_WIDTH = 0.9;
+var WIDE = 1.6;
+var MIN_K = 0.02;
+var STEPS = 22;
+var fontOf = (line, size, fonts) => `${line.weight} ${size}px ${fonts[line.role]}`;
+var emptyFlow = () => ({ texts: [], cards: [], rules: [], bullets: [] });
+function lineSize(line, width, k, avail) {
+  const indent = line.bullet ? line.size * k * BULLET_INDENT : 0;
+  return Math.max(0, Math.min(line.size * k, line.size * (avail - indent) / Math.max(width, 1)));
+}
+function groupRatio(m, k, avail) {
+  if (!m.group.uniform) {
+    return null;
+  }
+  return Math.min(...m.group.lines.map((line, i) => lineSize(line, m.widths[i] ?? 1, k, avail) / line.size));
+}
+function placeGroup(m, k, col, y0, out) {
+  const { group } = m;
+  let y = y0;
+  if (group.rule) {
+    out?.rules.push({ rect: { x: col.x, y, w: col.w * RULE_WIDTH, h: group.rule.height * k }, color: group.rule.color });
+    y += group.rule.height * k * RULE_GAP;
+  }
+  const pad = group.card ? group.card.pad * k : 0;
+  const top = y;
+  y += pad;
+  const ratio = groupRatio(m, k, col.w - 2 * pad);
+  group.lines.forEach((line, i) => {
+    const size = ratio === null ? lineSize(line, m.widths[i] ?? 1, k, col.w - 2 * pad) : line.size * ratio;
+    const indent = line.bullet ? line.size * k * BULLET_INDENT : 0;
+    const w = (m.widths[i] ?? 0) * size / line.size;
+    const x = col.right ? col.x + col.w - pad - w : col.x + pad + indent;
+    out?.texts.push({ text: line.text, font: "", color: line.color, box: { x, y, w, h: size * LINE_HEIGHT } });
+    if (line.bullet && out) {
+      out.bullets.push({ x: col.x + pad + size * BULLET_RADIUS, y: y + size * LINE_HEIGHT / 2, r: size * BULLET_RADIUS, color: line.bullet });
+    }
+    y += size * LINE_HEIGHT;
+  });
+  y += pad;
+  if (group.card) {
+    out?.cards.unshift({ rect: { x: col.x, y: top, w: col.w, h: y - top }, color: group.card.color });
+  }
+  return y + group.gapAfter * k - y0;
+}
+function placeColumn(groups, k, col, out) {
+  let h = 0;
+  for (const g of groups) {
+    h += placeGroup(g, k, col, col.y + h, out);
+  }
+  return h;
+}
+function splitColumns(groups, zone) {
+  if (zone.w / Math.max(zone.h, 1) <= WIDE || groups.length < 2) {
+    return [{ col: zone, groups }];
+  }
+  const heights = groups.map((g) => placeGroup(g, 1, zone, 0, null));
+  const half = heights.reduce((a, b) => a + b, 0) / 2;
+  let acc = 0;
+  let cut = 1;
+  heights.forEach((h, i) => {
+    if (acc < half) {
+      cut = i + 1;
+    }
+    acc += h;
+  });
+  cut = Math.min(cut, groups.length - 1);
+  const gap = Math.round(zone.w * 0.04);
+  const w = (zone.w - gap) / 2;
+  return [
+    { col: { ...zone, w }, groups: groups.slice(0, cut) },
+    { col: { ...zone, x: zone.x + w + gap, w }, groups: groups.slice(cut) }
+  ];
+}
+function flow(ctx, groups, zone, fonts) {
+  const measured = groups.map((group) => ({
+    group,
+    widths: group.lines.map((line) => {
+      ctx.font = fontOf(line, line.size, fonts);
+      return ctx.measureText(line.text).width;
+    })
+  }));
+  const columns = splitColumns(measured, zone);
+  const fits = (k) => columns.every((c) => placeColumn(c.groups, k, c.col, null) <= zone.h);
+  let lo = MIN_K;
+  let hi = 1;
+  if (fits(1)) {
+    lo = 1;
+  }
+  for (let i = 0; i < STEPS && lo < hi; i++) {
+    const mid = (lo + hi) / 2;
+    if (fits(mid)) {
+      lo = mid;
+    } else {
+      hi = mid;
+    }
+  }
+  const out = emptyFlow();
+  columns.forEach((c) => placeColumn(c.groups, lo, c.col, out));
+  const lines = groups.flatMap((g) => g.lines);
+  out.texts.forEach((t, i) => {
+    const line = lines[i];
+    t.font = line ? fontOf(line, t.box.h / LINE_HEIGHT, fonts) : t.font;
+  });
+  return out;
+}
+
+// src/render/render.ts
+var BASE = 1080;
+var LOGO_SHARE = 0.26;
+var CARD_RADIUS = 0.035;
+var CAP_TOP = 0.15;
+function roundRect(ctx, r3, radius) {
+  const rad = Math.min(radius, r3.w / 2, r3.h / 2);
+  ctx.beginPath();
+  ctx.moveTo(r3.x + rad, r3.y);
+  ctx.arcTo(r3.x + r3.w, r3.y, r3.x + r3.w, r3.y + r3.h, rad);
+  ctx.arcTo(r3.x + r3.w, r3.y + r3.h, r3.x, r3.y + r3.h, rad);
+  ctx.arcTo(r3.x, r3.y + r3.h, r3.x, r3.y, rad);
+  ctx.arcTo(r3.x, r3.y, r3.x + r3.w, r3.y, rad);
+  ctx.closePath();
+  ctx.fill();
+}
+function drawFlow(ctx, f, radius) {
+  f.rules.forEach((r3) => {
+    ctx.fillStyle = r3.color;
+    ctx.fillRect(r3.rect.x, r3.rect.y, r3.rect.w, r3.rect.h);
+  });
+  f.cards.forEach((c) => {
+    ctx.fillStyle = c.color;
+    roundRect(ctx, c.rect, radius);
+  });
+  f.bullets.forEach((b) => {
+    ctx.fillStyle = b.color;
+    ctx.beginPath();
+    ctx.arc(b.x, b.y, b.r, 0, Math.PI * 2);
+    ctx.fill();
+  });
+  ctx.textAlign = "left";
+  ctx.textBaseline = "top";
+  f.texts.forEach((t) => {
+    ctx.font = t.font;
+    ctx.fillStyle = t.color;
+    ctx.fillText(t.text, t.box.x, t.box.y);
+  });
+}
+function checked(input, assets) {
+  const result = validateFlierDoc(input);
+  if (!result.ok) {
+    throw new FlierDocError(result.errors);
+  }
+  const missing = missingAssets(result.doc, assets);
+  if (missing.length > 0) {
+    throw new FlierDocError(missing);
+  }
+  return result.doc;
+}
+function archRect(geo) {
+  if (geo.arch === void 0) {
+    return null;
+  }
+  const top = geo.picture.y + Math.round(geo.picture.h * geo.arch);
+  return { x: geo.picture.x, y: top, w: geo.picture.w, h: geo.picture.y + geo.picture.h - top };
+}
+function drawArch(ctx, r3, color) {
+  const rad = r3.w / 2;
+  ctx.fillStyle = color;
+  ctx.fillRect(r3.x, r3.y + rad, r3.w, r3.h - rad);
+  ctx.beginPath();
+  ctx.arc(r3.x + rad, r3.y + rad, rad, Math.PI, Math.PI * 2);
+  ctx.fill();
+}
+function flankFlows(ctx, groups, flanks, fonts) {
+  const half = Math.ceil(groups.length / 2);
+  return flanks.map((zone, i) => i === 0 ? flow(ctx, groups.slice(0, half), zone, fonts) : flow(ctx, groups.slice(half), { ...zone, right: true }, fonts));
+}
+function capAligned(zone, head) {
+  const first = head.texts[0]?.box;
+  const shift = first ? Math.min(Math.max(0, Math.round(first.y + first.h * CAP_TOP) - zone.y), Math.round(zone.h / 2)) : 0;
+  return { ...zone, y: zone.y + shift, h: zone.h - shift };
+}
+function splitHeader(header, hasLogo) {
+  const logoW = hasLogo ? Math.round(header.w * LOGO_SHARE) : 0;
+  return { text: { ...header, w: header.w - logoW * 1.1 }, logo: { ...header, x: header.x + header.w - logoW, w: logoW } };
+}
+function render(input, assets, canvas) {
+  const doc = checked(input, assets);
+  const { width, height } = FORMAT_SIZES[doc.format];
+  canvas.width = width;
+  canvas.height = height;
+  const ctx = canvas.getContext("2d");
+  if (!ctx) {
+    throw new Error("poster-render: the canvas has no 2d context");
+  }
+  const palette = PALETTES[doc.palette];
+  const fonts = FONT_SETS[doc.fonts];
+  const geo = geometry(doc.layout, width, height);
+  const u = Math.min(width, height) / BASE;
+  ctx.globalAlpha = 1;
+  ctx.fillStyle = palette.background;
+  ctx.fillRect(0, 0, width, height);
+  if (doc.background === "tint" /* Tint */) {
+    ctx.fillStyle = palette.tint;
+    [geo.header, geo.body].forEach((r3) => ctx.fillRect(r3.x, r3.y, r3.w, r3.h));
+  }
+  const zones = geo.logo ? { text: geo.header, logo: geo.logo } : splitHeader(geo.header, doc.logo !== void 0);
+  const head = flow(ctx, headerGroups(doc, palette, u), zones.text, fonts);
+  const flanks = geo.flanks ?? [];
+  const body = flow(ctx, bodyGroups(doc, palette, u, flanks.length === 0), geo.body, fonts);
+  const sides = flanks.length > 0 ? flankFlows(ctx, flankPriceGroups(doc, palette, u), flanks, fonts) : [emptyFlow()];
+  const radius = Math.min(width, height) * CARD_RADIUS;
+  [head, body, ...sides].forEach((f) => drawFlow(ctx, f, radius));
+  const logoImage = doc.logo ? assets[doc.logo.imageId] : void 0;
+  if (logoImage) {
+    const r3 = placeContain(logoImage, capAligned(zones.logo, head), "top" /* Top */, 1, 1);
+    ctx.drawImage(logoImage, r3.x, r3.y, r3.w, r3.h);
+  }
+  const image = doc.picture ? assets[doc.picture.imageId] : void 0;
+  const backdrop = image ? archRect(geo) : null;
+  if (backdrop) {
+    drawArch(ctx, backdrop, palette.arch);
+  }
+  const picture = image && doc.picture ? placeContain(image, geo.picture, doc.picture.anchor, geo.alignX, doc.picture.scale) : null;
+  if (image && picture) {
+    ctx.drawImage(image, picture.x, picture.y, picture.w, picture.h);
+  }
+  return {
+    width,
+    height,
+    picture,
+    pictureRegion: geo.picture,
+    textBoxes: [head, body, ...sides].flatMap((f) => f.texts.map((t) => t.box)),
+    cardBoxes: body.cards.map((c) => c.rect),
+    backdrop
+  };
+}
+
+// src/exportPng.ts
+var PREFIX = "data:image/png;base64,";
+function exportPng(canvas) {
+  const url = canvas.toDataURL("image/png");
+  if (!url.startsWith(PREFIX)) {
+    throw new Error("poster-render: the canvas did not return a PNG data URL");
+  }
+  const binary = atob(url.slice(PREFIX.length));
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new Blob([bytes], { type: "image/png" });
+}
+
+// src/layoutCatalogue.ts
+var POSTERS = ["story" /* Story */, "post" /* Post */, "square" /* Square */];
+var LAYOUT_CATALOGUE = [
+  { id: "picture-right" /* PictureRight */, designId: "E-A", label: "Picture right", description: "Titles across the top, details on the left, the picture on the right standing on the bottom edge.", formats: POSTERS },
+  { id: "picture-left" /* PictureLeft */, designId: "E-B", label: "Picture left", description: "Titles across the top, the picture on the left standing on the bottom edge, details on the right.", formats: POSTERS },
+  { id: "arch" /* Arch */, designId: "E-C", label: "Arch", description: "Titles and details on top, the picture centred in a soft arch at the bottom, prices either side.", formats: POSTERS },
+  { id: "picture-bottom" /* PictureBottom */, designId: "picture-bottom", label: "Picture bottom", description: "Titles and details on top, the picture across the bottom half.", formats: POSTERS },
+  { id: "list" /* List */, designId: "list", label: "Upcoming list", description: "Several dated events as a list beside the picture.", formats: POSTERS },
+  { id: "phone-clock-safe" /* PhoneClockSafe */, designId: "P-A", label: "Phone, clock clear", description: "Lock-screen wallpaper: top kept clear for the clock, details on the left, picture on the right.", formats: ["phone" /* Phone */] },
+  { id: "phone-arch" /* PhoneArch */, designId: "P-B", label: "Phone arch", description: "Lock-screen wallpaper: top kept clear for the clock, details in the middle, the picture in an arch at the bottom.", formats: ["phone" /* Phone */] },
+  { id: "desktop-safe" /* DesktopSafe */, designId: "D-A", label: "Desktop, icons clear", description: "Desktop wallpaper: text on the left clear of desktop icons and the taskbar, the picture on the right.", formats: ["desktop" /* Desktop */] },
+  { id: "desktop-arch" /* DesktopArch */, designId: "D-B", label: "Desktop arch", description: "Desktop wallpaper: titles left, the picture in a centred arch, details right.", formats: ["desktop" /* Desktop */] }
+];
+var DEFAULTS = {
+  ["story" /* Story */]: "picture-right" /* PictureRight */,
+  ["post" /* Post */]: "picture-right" /* PictureRight */,
+  ["square" /* Square */]: "picture-right" /* PictureRight */,
+  ["phone" /* Phone */]: "phone-clock-safe" /* PhoneClockSafe */,
+  ["desktop" /* Desktop */]: "desktop-safe" /* DesktopSafe */
+};
+function defaultLayoutFor(format) {
+  return DEFAULTS[format];
+}
+
+// src/examples/kizombaWorkshop.ts
+var WORKSHOPS = [
+  { script: "Saturday 31 October", date: "Sat 31 Oct", first: "20:00 - 21:00", second: "21:00 - 22:00", party: "20\u20AC" },
+  { script: "Saturday 7 November", date: "Sat 7 Nov", first: "20:00 - 21:00", second: "21:00 - 22:00", party: "15\u20AC" },
+  { script: "Sunday 29 November", date: "Sun 29 Nov", first: "17:00 - 18:00", second: "18:00 - 19:00", party: "10\u20AC" }
+];
+var INCLUDES = { heading: "Party pass includes", items: ["Salsa & Bachata room", "Kizomba dedicated room", "2 drinks"] };
+var schedule = (w) => [
+  { label: "Level 1", time: w.first },
+  { label: "Level 2", time: w.second }
+];
+var base = {
+  version: 1,
+  format: "story" /* Story */,
+  palette: "sand" /* Sand */,
+  fonts: "classic" /* Classic */,
+  background: "solid" /* Solid */,
+  picture: { imageId: "dancers", anchor: "bottom" /* Bottom */, scale: 1 },
+  logo: { imageId: "logo" }
+};
+var shared = {
+  venue: ["Bailemos", "Dance School"],
+  includes: INCLUDES,
+  footer: "with Jimmy & Ismini"
+};
+var workshopDoc = (w) => ({
+  ...base,
+  layout: "picture-right" /* PictureRight */,
+  blocks: {
+    ...shared,
+    title: "KIZOMBA",
+    titleBottom: "WORKSHOP",
+    script: w.script,
+    schedule: schedule(w),
+    prices: [{ amount: "5\u20AC", label: "per hour" }, { amount: w.party, label: "Party pass" }]
+  }
+});
+var kizombaWorkshop = {
+  ...base,
+  layout: "list" /* List */,
+  blocks: {
+    ...shared,
+    title: "UPCOMING",
+    titleBottom: "WORKSHOPS",
+    script: "Kizomba",
+    prices: [{ amount: "5\u20AC", label: "per hour" }]
+  },
+  items: WORKSHOPS.map((w) => ({ date: w.date, schedule: schedule(w), price: `Party pass ${w.party}` }))
+};
+var kizombaWorkshopDocs = [...WORKSHOPS.map(workshopDoc), kizombaWorkshop];
+
+export { BackgroundStyle, FONT_SETS, FORMAT_SIZES, FlierDocError, FontSetId, FormatId, LAYOUT_CATALOGUE, LayoutId, PALETTES, PaletteId, PictureAnchor, defaultLayoutFor, exportPng, flierDocSchema, kizombaWorkshop, kizombaWorkshopDocs, render, validateFlierDoc };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map