@lacspace/image 1.0.0 → 1.1.0

package/README.md

@@ -58,6 +58,20 @@ console.log(formatBytes(r.size), "at q", r.quality, `${r.width}×${r.height}`);
 
 > It's a best-effort **ceiling** — the closest fit ≤ your budget within the quality/scale bounds, never padded up to it.
 
+## 🆕 Generators (v1.1.0)
+
+Deterministic, no-AI building blocks — same input, same image:
+
+```ts
+import { identicon, mesh, placeholder, encode } from "@lacspace/image";
+
+const avatar = identicon("ada@lacspace.com", { size: 240 });     // symmetric avatar from any string
+const bg     = mesh(1200, 630, { seed: "brand" });               // smooth multi-point mesh gradient
+const lqip   = placeholder(600, 315, { seed: "hero-1" });        // tasteful seeded gradient placeholder
+
+const png = await encode(avatar, { format: "png" });
+```
+
 ## The surface API
 
 `Surface` is a plain RGBA pixel buffer with a small, chainable drawing API. Everything is deterministic and identical across Node and the browser.
@@ -129,6 +143,10 @@ formatBytes(1536);   // "1.5 KB"
 - `rasterizeSvg(svg, { width?, height?, background? })`
 - `Surface`, `gradient`, `radial`, `pattern`, `parseColor`, `parseSize`, `formatBytes`, `hasCanvas`, `canvasSupports`
 
+## Contributing 💙
+
+New patterns, generators and encoders are welcome — see [CONTRIBUTING.md](https://github.com/lacspace/npm-packages/blob/main/CONTRIBUTING.md). Open an issue or PR; first-time contributors welcome.
+
 ## License
 
 [Lacspace Free Licence v1.0](https://github.com/lacspace/npm-packages/blob/main/LICENSE) — free to use, permissive, Lacspace-branded.

package/dist/index.cjs

@@ -369,6 +369,119 @@ function pattern(width, height, base, kind, opts) {
   return new Surface(width, height).fill(base).pattern(kind, opts);
 }
 
+// src/generators.ts
+function hash32(str) {
+  let h = 2166136261 >>> 0;
+  for (let i = 0; i < str.length; i++) {
+    h ^= str.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return h >>> 0;
+}
+function rng2(seed) {
+  let s = seed >>> 0 || 1;
+  return () => {
+    s |= 0;
+    s = s + 1831565813 | 0;
+    let t = Math.imul(s ^ s >>> 15, 1 | s);
+    t = t + Math.imul(t ^ t >>> 7, 61 | t) ^ t;
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function hsl(h, s, l) {
+  h = (h % 360 + 360) % 360;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h < 60) [r, g, b] = [c, x, 0];
+  else if (h < 120) [r, g, b] = [x, c, 0];
+  else if (h < 180) [r, g, b] = [0, c, x];
+  else if (h < 240) [r, g, b] = [0, x, c];
+  else if (h < 300) [r, g, b] = [x, 0, c];
+  else [r, g, b] = [c, 0, x];
+  return [Math.round((r + m) * 255), Math.round((g + m) * 255), Math.round((b + m) * 255), 255];
+}
+function identicon(seed, opts = {}) {
+  const size = opts.size ?? 240;
+  const grid = Math.max(3, (opts.grid ?? 5) | 1);
+  const h = hash32(seed);
+  const rand = rng2(h);
+  const fgRgba = hsl(h % 360, 0.62, 0.58);
+  const fg = opts.color ?? `rgb(${fgRgba[0]},${fgRgba[1]},${fgRgba[2]})`;
+  const s = new Surface(size, size).fill(opts.background ?? "#0f1117");
+  const pad = Math.round(size * (opts.padding ?? 0.12));
+  const cell = (size - pad * 2) / grid;
+  const half = Math.ceil(grid / 2);
+  for (let col = 0; col < half; col++) {
+    for (let row = 0; row < grid; row++) {
+      if (rand() > 0.5) {
+        const mirror = grid - 1 - col;
+        const y = pad + row * cell;
+        s.rect(pad + col * cell, y, Math.ceil(cell), Math.ceil(cell), fg);
+        if (mirror !== col) s.rect(pad + mirror * cell, y, Math.ceil(cell), Math.ceil(cell), fg);
+      }
+    }
+  }
+  return s;
+}
+var DEFAULT_MESH = ["#0BB9D9", "#3B82F6", "#7C3AED", "#EC4899", "#22D3EE"];
+function mesh(width, height, opts = {}) {
+  const palette = (opts.colors ?? DEFAULT_MESH).map(parseColor);
+  const n = Math.max(2, opts.points ?? palette.length);
+  const seed = typeof opts.seed === "number" ? opts.seed : hash32(String(opts.seed ?? "mesh"));
+  const rand = rng2(seed);
+  const pts = Array.from({ length: n }, (_, i) => ({
+    x: rand() * width,
+    y: rand() * height,
+    c: palette[i % palette.length]
+  }));
+  const out = new Surface(width, height);
+  const d = out.data;
+  for (let y = 0; y < height; y++) {
+    for (let x = 0; x < width; x++) {
+      let wr = 0, wg = 0, wb = 0, wsum = 0;
+      for (const p of pts) {
+        const dx = x - p.x;
+        const dy = y - p.y;
+        const w = 1 / (dx * dx + dy * dy + 800);
+        wr += p.c[0] * w;
+        wg += p.c[1] * w;
+        wb += p.c[2] * w;
+        wsum += w;
+      }
+      const i = (y * width + x) * 4;
+      d[i] = wr / wsum;
+      d[i + 1] = wg / wsum;
+      d[i + 2] = wb / wsum;
+      d[i + 3] = 255;
+    }
+  }
+  return out;
+}
+function placeholder(width, height, opts = {}) {
+  const seed = typeof opts.seed === "number" ? opts.seed : hash32(String(opts.seed ?? `${width}x${height}`));
+  const rand = rng2(seed);
+  let from, to;
+  if (opts.colors) {
+    [from, to] = [parseColor(opts.colors[0]), parseColor(opts.colors[1])];
+  } else {
+    const base = Math.floor(rand() * 360);
+    from = hsl(base, 0.55, 0.55);
+    to = hsl(base + 40 + rand() * 60, 0.55, 0.45);
+  }
+  const angle = Math.floor(rand() * 180);
+  const s = new Surface(width, height).linearGradient({
+    angle,
+    stops: [
+      { offset: 0, color: `rgb(${from[0]},${from[1]},${from[2]})` },
+      { offset: 1, color: `rgb(${to[0]},${to[1]},${to[2]})` }
+    ]
+  });
+  if (opts.texture !== false) s.pattern("dots", { size: Math.max(20, Math.round(width / 24)), color: "rgba(255,255,255,0.08)" });
+  return s;
+}
+
 // src/env.ts
 function hasCanvas() {
   if (typeof OffscreenCanvas !== "undefined") return true;
@@ -1589,9 +1702,12 @@ exports.fit = fit;
 exports.formatBytes = formatBytes;
 exports.gradient = gradient;
 exports.hasCanvas = hasCanvas;
+exports.identicon = identicon;
+exports.mesh = mesh;
 exports.parseColor = parseColor;
 exports.parseSize = parseSize;
 exports.pattern = pattern;
+exports.placeholder = placeholder;
 exports.radial = radial;
 exports.rasterizeSvg = rasterizeSvg;
 //# sourceMappingURL=index.cjs.map