@arraypress/covers 1.1.0 → 1.3.1

package/src/render/content.js

@@ -1,58 +0,0 @@
-/**
- * Where a layer paints: its markup drawn small and the box round every
- * pixel it covers, so filters can work over that box instead of the whole
- * canvas (in `renderImage`, where librsvg's cost is per pixel of region).
- *
- * @module render/content
- */
-
-import { num } from '../svg.js';
-
-/** The probe's longer side, px. */
-const PROBE = 256;
-
-/** Markup carrying more embedded data than this isn't probed (decoding it would cost more than it saves). */
-const MAX_PROBE_BYTES = 400_000;
-
-/**
- * The box a layer's markup paints, in its units: drawn at most 256 px
- * across over the canvas and half again round it, one probe pixel of slack
- * on every side. Undefined when it can't be probed (no sharp, heavy
- * embedded images) or paints nothing.
- *
- * @param {{ defs: string, body: string }} m
- * @param {any} ctx
- * @returns {Promise<{ x: number, y: number, width: number, height: number } | undefined>}
- */
-export async function contentBox(m, ctx) {
-  if (!ctx.raster || !ctx.sharp || m.body.length + m.defs.length > MAX_PROBE_BYTES) return undefined;
-  const ox = -ctx.width / 2;
-  const oy = -ctx.height / 2;
-  const uw = ctx.width * 2;
-  const uh = ctx.height * 2;
-  const s = PROBE / Math.max(uw, uh);
-  const w = Math.max(1, Math.round(uw * s));
-  const h = Math.max(1, Math.round(uh * s));
-  const doc = `<svg xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="${num(ox, 4)} ${num(oy, 4)} ${num(uw, 4)} ${num(uh, 4)}" preserveAspectRatio="none">${m.defs ? `<defs>${m.defs}</defs>` : ''}${m.body}</svg>`;
-  let px;
-  try {
-    px = await ctx.sharp(new TextEncoder().encode(doc)).ensureAlpha().raw().toBuffer();
-  } catch {
-    return undefined;
-  }
-  let x0 = w;
-  let y0 = h;
-  let x1 = -1;
-  let y1 = -1;
-  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
-    if (!px[(y * w + x) * 4 + 3]) continue;
-    if (x < x0) x0 = x;
-    if (x > x1) x1 = x;
-    if (y < y0) y0 = y;
-    if (y > y1) y1 = y;
-  }
-  if (x1 < 0) return undefined;
-  // Anything touching the probe's edge may run further: the whole region then.
-  if (x0 === 0 || y0 === 0 || x1 === w - 1 || y1 === h - 1) return undefined;
-  return { x: ox + (x0 - 1) / s, y: oy + (y0 - 1) / s, width: (x1 - x0 + 3) / s, height: (y1 - y0 + 3) / s };
-}

package/src/render/tiles.d.ts

@@ -1,6 +0,0 @@
-// Large SVGs with filters, rasterised in tiles.
-
-/** An SVG document's RGBA pixels at its own size (in tiles when large and filtered). */
-export function svgPixels(sharp: unknown, svg: string, width: number, height: number, known?: number): Promise<Uint8Array>;
-/** How far any filter in a document reaches, output px, estimated from its markup. */
-export function reach(svg: string): number;

package/src/render/tiles.js

@@ -1,77 +0,0 @@
-/**
- * Rasterising a large SVG with filters in tiles.
- *
- * librsvg (through libvips) slows down sharply past a few megapixels when
- * a document has filters: a 3000² displacement map takes ~28 s in one
- * render and ~5 s as four 1500² tiles. So a large document with filters is
- * drawn as tiles, each with a margin round it (librsvg clips a filter's
- * input to the viewport, so a blur or displacement at a tile's edge needs
- * the pixels beyond it: the margin is the furthest any filter reaches),
- * cropped and assembled. Tiles render in parallel. A document whose
- * filters reach further than a tile renders in one piece.
- *
- * @module render/tiles
- */
-
-import { filterReach } from '../effects/region.js';
-
-/** Documents below this many pixels render in one piece. */
-const MIN_TILED = 2.4e6;
-
-/** Tile side, px (before margins). */
-const TILE = 1024;
-
-/**
- * An SVG document's RGBA pixels at its own size.
- *
- * @param {any} sharp
- * @param {string} svg - A document whose root is `width`×`height` with `viewBox="0 0 width height"`.
- * @param {number} width
- * @param {number} height
- * @param {number} [known=0] - How far the filters the layers drew reach, output px (they report it at their own resolution).
- * @returns {Promise<Uint8Array>}
- */
-export async function svgPixels(sharp, svg, width, height, known = 0) {
-  const margin = width * height < MIN_TILED || !/<filter\b/.test(svg) ? Infinity : Math.max(known + 16, reach(svg));
-  // Filters reaching further than a tile (a heavy blur) render in one piece.
-  if (margin > TILE) return sharp(Buffer.from(svg)).ensureAlpha().raw().toBuffer();
-  const open = /^<svg\b[^>]*>/.exec(svg);
-  if (!open) return sharp(Buffer.from(svg)).ensureAlpha().raw().toBuffer();
-  const rest = svg.slice(open[0].length);
-  const root = open[0].replace(/\s(width|height|viewBox)="[^"]*"/g, '').replace(/>$/, '');
-  const out = Buffer.alloc(width * height * 4);
-  /** @type {(() => Promise<void>)[]} */
-  const jobs = [];
-  for (let y = 0; y < height; y += TILE) {
-    for (let x = 0; x < width; x += TILE) {
-      const tw = Math.min(TILE, width - x);
-      const th = Math.min(TILE, height - y);
-      jobs.push(async () => {
-        const vw = tw + 2 * margin;
-        const vh = th + 2 * margin;
-        const doc = `${root} width="${vw}" height="${vh}" viewBox="${x - margin} ${y - margin} ${vw} ${vh}">${rest}`;
-        const px = await sharp(Buffer.from(doc)).ensureAlpha().extract({ left: margin, top: margin, width: tw, height: th }).raw().toBuffer();
-        for (let r = 0; r < th; r++) px.copy(out, ((y + r) * width + x) * 4, r * tw * 4, (r + 1) * tw * 4);
-      });
-    }
-  }
-  // A few at a time: each holds its filter surfaces.
-  const lanes = 4;
-  await Promise.all(Array.from({ length: lanes }, async (_, i) => { for (let j = i; j < jobs.length; j += lanes) await jobs[j](); }));
-  return out;
-}
-
-/**
- * How far, in output px, any filter in a document reaches, estimated from
- * the markup: the primitives' reach times the largest scale it's drawn at.
- * (Effects report their own reach at their own resolution; this covers
- * filters written by other layers.)
- *
- * @param {string} svg
- * @returns {number}
- */
-export function reach(svg) {
-  let scale = 1;
-  for (const m of svg.matchAll(/scale\(([^)]*)\)/g)) for (const v of m[1].trim().split(/[\s,]+/)) scale = Math.max(scale, Math.abs(Number(v)) || 0);
-  return Math.ceil(filterReach(svg) * scale) + 16;
-}

package/src/rng.js

@@ -1,95 +0,0 @@
-/**
- * Seeded randomness.
- *
- * Every random choice a cover makes comes from a generator seeded by the
- * cover's `seed` string, so the same input always draws the same image and
- * two posts with different slugs draw different ones. Each layer gets its
- * own stream (seed + layer index + layer type), so adding or removing one
- * layer never reshuffles the others.
- *
- * @module rng
- */
-
-/**
- * Hash a string to a 32-bit unsigned integer (cyrb53, folded to 32 bits).
- * Fast, well distributed, and stable across platforms and Node versions.
- *
- * @param {string} str - Any string.
- * @param {number} [salt=0] - Optional salt, to get several independent hashes of one string.
- * @returns {number} An integer in `[0, 2^32)`.
- *
- * @example
- * hashString('my-post');  // 1838215339 (always)
- */
-export function hashString(str, salt = 0) {
-  let h1 = 0xdeadbeef ^ salt;
-  let h2 = 0x41c6ce57 ^ salt;
-  for (let i = 0; i < str.length; i++) {
-    const ch = str.charCodeAt(i);
-    h1 = Math.imul(h1 ^ ch, 2654435761);
-    h2 = Math.imul(h2 ^ ch, 1597334677);
-  }
-  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909);
-  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909);
-  return (h1 ^ h2) >>> 0;
-}
-
-/**
- * A small seeded pseudo-random generator (sfc32) with helpers.
- *
- * @typedef {object} Rng
- * @property {() => number} next - A float in `[0, 1)`.
- * @property {(min: number, max: number) => number} range - A float in `[min, max)`.
- * @property {(min: number, max: number) => number} int - An integer in `[min, max]`.
- * @property {<T>(items: readonly T[]) => T} pick - One item.
- * @property {<T>(items: readonly T[]) => T[]} shuffle - A shuffled copy.
- * @property {(chance?: number) => boolean} chance - `true` with the given probability (default 0.5).
- */
-
-/**
- * Create a seeded generator. Strings are hashed; numbers are used as-is.
- *
- * @param {string | number} seed - The seed.
- * @returns {Rng} The generator.
- *
- * @example
- * const rng = createRng('my-post');
- * rng.range(0, 360); // same angle every run
- */
-export function createRng(seed) {
-  const s = String(seed);
-  let a = hashString(s, 1);
-  let b = hashString(s, 2);
-  let c = hashString(s, 3);
-  let d = hashString(s, 4);
-
-  const next = () => {
-    a >>>= 0; b >>>= 0; c >>>= 0; d >>>= 0;
-    let t = (a + b) | 0;
-    a = b ^ (b >>> 9);
-    b = (c + (c << 3)) | 0;
-    c = (c << 21) | (c >>> 11);
-    d = (d + 1) | 0;
-    t = (t + d) | 0;
-    c = (c + t) | 0;
-    return (t >>> 0) / 4294967296;
-  };
-  // Warm up: the first few sfc32 outputs are correlated with the seed.
-  for (let i = 0; i < 12; i++) next();
-
-  return {
-    next,
-    range: (min, max) => min + next() * (max - min),
-    int: (min, max) => Math.floor(min + next() * (max - min + 1)),
-    pick: (items) => items[Math.floor(next() * items.length)],
-    shuffle: (items) => {
-      const out = items.slice();
-      for (let i = out.length - 1; i > 0; i--) {
-        const j = Math.floor(next() * (i + 1));
-        [out[i], out[j]] = [out[j], out[i]];
-      }
-      return out;
-    },
-    chance: (p = 0.5) => next() < p,
-  };
-}

package/src/svg.js

@@ -1,69 +0,0 @@
-/**
- * Small helpers for writing SVG markup deterministically.
- *
- * Numbers are always written through {@link num}, so the same input gives
- * byte-identical output on every machine (no `0.30000000000000004`, no
- * locale formatting, no `-0`).
- *
- * @module svg
- */
-
-/**
- * Format a number for SVG: at most `digits` decimals, no trailing zeros.
- *
- * @param {number} v - The number.
- * @param {number} [digits=2] - Maximum decimals.
- * @returns {string} The formatted number.
- *
- * @example
- * num(1 / 3);   // '0.33'
- * num(12.5);    // '12.5'
- * num(-0.001);  // '0'
- */
-export function num(v, digits = 2) {
-  if (!Number.isFinite(v)) return '0';
-  const s = v.toFixed(digits).replace(/\.?0+$/, '');
-  return s === '-0' || s === '' ? '0' : s;
-}
-
-/**
- * Escape text for an XML attribute or text node.
- *
- * @param {string} s - Raw text.
- * @returns {string} Escaped text.
- */
-export function esc(s) {
-  return String(s).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c]);
-}
-
-/**
- * Serialise an attribute object. `undefined`, `null` and `false` values are
- * skipped; numbers go through {@link num}. Keys keep their insertion order.
- *
- * @param {Record<string, string | number | boolean | null | undefined>} obj - Attributes.
- * @returns {string} ` key="value"` pairs (with a leading space), or `''`.
- *
- * @example
- * attrs({ x: 1.005, fill: '#fff', opacity: undefined }); // ' x="1" fill="#fff"'
- */
-export function attrs(obj) {
-  let out = '';
-  for (const [k, v] of Object.entries(obj)) {
-    if (v === undefined || v === null || v === false) continue;
-    out += ` ${k}="${typeof v === 'number' ? num(v) : esc(String(v))}"`;
-  }
-  return out;
-}
-
-/**
- * Opacity and blend-mode attributes shared by every layer.
- *
- * @param {{ opacity?: number, blend?: string }} layer - The layer.
- * @returns {Record<string, string | number | undefined>} Attributes for the layer's group.
- */
-export function layerAttrs(layer) {
-  return {
-    opacity: layer.opacity != null && layer.opacity < 1 ? Math.max(0, layer.opacity) : undefined,
-    style: layer.blend && layer.blend !== 'normal' ? `mix-blend-mode:${layer.blend}` : undefined,
-  };
-}