@gongbaodd/qr-renderer 0.1.0

package/src/recipe.ts

@@ -0,0 +1,161 @@
+import { z } from 'zod'
+import type { Imaging } from './core/imaging/types'
+import { assemblePayload } from './engine/pipeline'
+import type { AssembleInput } from './engine/index'
+import { parsePngHeader } from './png-guard'
+import { MAX_IMAGE_BYTES, MAX_PIXELS, contentSchema, placementSchema, settingsSchema } from './schema'
+import type { Settings } from './schema'
+import { engineDefaults } from './engine/pipeline'
+
+export const RECIPE_FORMAT = 'mahu-qr-recipe'
+export const RECIPE_SCHEMA_VERSION = 1
+export const RECIPE_RENDERER_VERSION = 'mahu-qr-renderer-1'
+export const MAX_RECIPE_BYTES = 28 * 1024 * 1024
+
+const MAX_BASE64_IMAGE_CHARS = Math.ceil(MAX_IMAGE_BYTES / 3) * 4
+const digestSchema = z.string().regex(/^[0-9a-f]{64}$/)
+const embeddedPngSchema = z
+  .object({
+    mimeType: z.literal('image/png'),
+    encoding: z.literal('base64'),
+    sha256: digestSchema,
+    data: z.string().min(4).max(MAX_BASE64_IMAGE_CHARS),
+  })
+  .strict()
+
+export const recipeSchema = z
+  .object({
+    format: z.literal(RECIPE_FORMAT),
+    schemaVersion: z.literal(RECIPE_SCHEMA_VERSION),
+    rendererVersion: z.literal(RECIPE_RENDERER_VERSION),
+    content: contentSchema,
+    source: z
+      .object({
+        poster: embeddedPngSchema,
+        regionMask: embeddedPngSchema,
+        width: z.number().int().positive().max(MAX_PIXELS),
+        height: z.number().int().positive().max(MAX_PIXELS),
+        transparentBlank: z.boolean(),
+      })
+      .strict()
+      .refine(({ width, height }) => width * height <= MAX_PIXELS, 'Image exceeds the pixel limit.'),
+    placement: placementSchema,
+    settings: settingsSchema,
+  })
+  .strict()
+
+export type PortableRecipe = z.infer<typeof recipeSchema>
+
+function toBase64(bytes: Uint8Array): string {
+  const blockSize = 0x6000
+  const encoded: string[] = []
+  for (let offset = 0; offset < bytes.length; offset += blockSize) {
+    const end = Math.min(offset + blockSize, bytes.length)
+    let chunk = ''
+    for (let index = offset; index < end; index++) chunk += String.fromCharCode(bytes[index]!)
+    encoded.push(btoa(chunk))
+  }
+  return encoded.join('')
+}
+
+function fromBase64(value: string): Uint8Array {
+  if (!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))
+    throw new Error('Recipe image data is not valid base64.')
+  const binary = atob(value)
+  if (binary.length > MAX_IMAGE_BYTES) throw new Error('Recipe PNG must be 10 MiB or smaller.')
+  const bytes = new Uint8Array(binary.length)
+  for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index)
+  return bytes
+}
+
+async function sha256Hex(bytes: Uint8Array): Promise<string> {
+  const digest = await crypto.subtle.digest('SHA-256', bytes.slice().buffer)
+  return [...new Uint8Array(digest)].map((byte) => byte.toString(16).padStart(2, '0')).join('')
+}
+
+function normalizedSettings(input: AssembleInput): Settings {
+  return settingsSchema.parse({
+    ...engineDefaults,
+    seed: input.seed,
+    qrMargin: input.qrMargin,
+    plateCorners: input.plateCorners,
+    regionMargin: input.regionMargin,
+    rimModules: input.rimModules,
+    rimRounded: input.rimRounded,
+    ecc: input.ecc,
+    pixelStyle: input.pixelStyle,
+    finderMarkers: input.finderMarkers,
+    markerSub: input.markerSub,
+    colors: input.colors,
+  })
+}
+
+export async function createRecipeBlob(input: AssembleInput, finalMask: Blob): Promise<Blob> {
+  const [poster, regionMask] = await Promise.all([
+    Promise.resolve(new Uint8Array(input.posterBytes)),
+    finalMask.arrayBuffer().then((bytes) => new Uint8Array(bytes)),
+  ])
+  if (poster.length > MAX_IMAGE_BYTES || regionMask.length > MAX_IMAGE_BYTES)
+    throw new Error('The source poster and final region mask must each be 10 MiB or smaller to export a recipe.')
+  const posterHeader = parsePngHeader(poster, 'poster')
+  const maskHeader = parsePngHeader(regionMask, 'mask')
+  if (posterHeader.width !== maskHeader.width || posterHeader.height !== maskHeader.height)
+    throw new Error('The final region mask must match the poster dimensions.')
+  const [posterSha, maskSha] = await Promise.all([sha256Hex(poster), sha256Hex(regionMask)])
+  const recipe = recipeSchema.parse({
+    format: RECIPE_FORMAT,
+    schemaVersion: RECIPE_SCHEMA_VERSION,
+    rendererVersion: RECIPE_RENDERER_VERSION,
+    content: input.content,
+    source: {
+      poster: { mimeType: 'image/png', encoding: 'base64', sha256: posterSha, data: toBase64(poster) },
+      regionMask: {
+        mimeType: 'image/png',
+        encoding: 'base64',
+        sha256: maskSha,
+        data: toBase64(regionMask),
+      },
+      width: posterHeader.width,
+      height: posterHeader.height,
+      transparentBlank: input.transparentBlank ?? false,
+    },
+    placement: input.placement,
+    settings: normalizedSettings(input),
+  })
+  return new Blob([JSON.stringify(recipe)], { type: 'application/json' })
+}
+
+export async function renderRecipe(
+  imaging: Imaging,
+  rawRecipe: unknown,
+  artifact: 'poster.png' | 'qr.png',
+): Promise<{ png: Blob; filename: string }> {
+  const recipe = recipeSchema.parse(rawRecipe)
+  const poster = fromBase64(recipe.source.poster.data)
+  const regionMask = fromBase64(recipe.source.regionMask.data)
+  const [posterSha, maskSha] = await Promise.all([sha256Hex(poster), sha256Hex(regionMask)])
+  if (posterSha !== recipe.source.poster.sha256 || maskSha !== recipe.source.regionMask.sha256)
+    throw new Error('Recipe image digest does not match its bytes.')
+  const posterHeader = parsePngHeader(poster, 'poster')
+  const maskHeader = parsePngHeader(regionMask, 'mask')
+  if (
+    posterHeader.width !== recipe.source.width ||
+    posterHeader.height !== recipe.source.height ||
+    maskHeader.width !== recipe.source.width ||
+    maskHeader.height !== recipe.source.height
+  )
+    throw new Error('Recipe image dimensions do not match the declared dimensions.')
+
+  const settings = recipe.settings
+  const assembled = await assemblePayload(imaging, {
+    posterBytes: poster,
+    maskBytes: regionMask,
+    transparentBlank: recipe.source.transparentBlank,
+    content: recipe.content,
+    placement: recipe.placement,
+    ...settings,
+  })
+  const png = assembled.artifacts[artifact]
+  if (!png) throw new Error(`Renderer did not produce ${artifact}.`)
+  return { png, filename: artifact }
+}

package/src/schema.ts

@@ -0,0 +1,137 @@
+import { z } from 'zod'
+import { DEFAULT_PALETTE, HEX_PATTERN } from './core/palette'
+import { canonicalizeRotation, localPointInPlate, posterToPlatePoint, rotatedFootprintBounds } from './core/rotate'
+
+export const MAX_IMAGE_BYTES = 10 * 1024 * 1024
+export const MAX_PIXELS = 4_000_000
+export const MAX_BODY_BYTES = 2 * MAX_IMAGE_BYTES + 64 * 1024
+export const contentSchema = z
+  .string()
+  .max(8000, 'Text exceeds QR capacity.')
+  .refine((s) => s.trim().length > 0, 'Enter text or a URL.')
+  .refine((s) => !/[\r\n]/.test(s), 'Use one line only.')
+export const rotationSchema = z.number().finite().default(0)
+export const placementSchema = z
+  .object({
+    x: z.number().int(),
+    y: z.number().int(),
+    size: z.number().int().positive(),
+    rotation: rotationSchema,
+  })
+  .strict()
+export const settingsSchema = z
+  .object({
+    seed: z.number().int().min(0).max(0xffffffff),
+    qrMargin: z.literal(1).default(1),
+    plateCorners: z.enum(['texture', 'light']).default('texture'),
+    regionMargin: z.boolean().default(false),
+    rimModules: z.number().int().min(0).max(5).default(1),
+    rimRounded: z.boolean().default(false),
+    ecc: z.enum(['L', 'M', 'Q', 'H']).default('M'),
+    pixelStyle: z.enum(['square', 'rounded', 'dot']).default('dot'),
+    finderMarkers: z
+      .object({
+        tl: z
+          .object({
+            style: z.enum(['square', 'rounded']).default('rounded'),
+            shape: z.enum(['square', 'circle', 'octagon', 'squircle']).default('circle'),
+            inner: z.enum(['square', 'circle', 'plus', 'diamond', 'squircle']).default('circle'),
+          })
+          .default({ style: 'rounded', shape: 'circle', inner: 'circle' }),
+        tr: z
+          .object({
+            style: z.enum(['square', 'rounded']).default('rounded'),
+            shape: z.enum(['square', 'circle', 'octagon', 'squircle']).default('circle'),
+            inner: z.enum(['square', 'circle', 'plus', 'diamond', 'squircle']).default('circle'),
+          })
+          .default({ style: 'rounded', shape: 'circle', inner: 'circle' }),
+        bl: z
+          .object({
+            style: z.enum(['square', 'rounded']).default('rounded'),
+            shape: z.enum(['square', 'circle', 'octagon', 'squircle']).default('circle'),
+            inner: z.enum(['square', 'circle', 'plus', 'diamond', 'squircle']).default('circle'),
+          })
+          .default({ style: 'rounded', shape: 'circle', inner: 'circle' }),
+      })
+      .default({
+        tl: { style: 'rounded', shape: 'circle', inner: 'circle' },
+        tr: { style: 'rounded', shape: 'circle', inner: 'circle' },
+        bl: { style: 'rounded', shape: 'circle', inner: 'circle' },
+      }),
+    markerSub: z.enum(['square', 'circle']).default('square'),
+    colors: z
+      .object({
+        pixel: z.string().regex(HEX_PATTERN),
+        marker: z.string().regex(HEX_PATTERN),
+        background: z.string().regex(HEX_PATTERN),
+      })
+      .default(DEFAULT_PALETTE),
+  })
+  .strict()
+export const requestSchema = z
+  .object({
+    revision: z.number().int().nonnegative(),
+    content: contentSchema,
+    placement: placementSchema.optional(),
+    previousTotalModules: z.number().int().min(25).max(181).optional(),
+    settings: settingsSchema,
+  })
+  .strict()
+export type Placement = z.infer<typeof placementSchema>
+export type Settings = z.infer<typeof settingsSchema>
+export type EditorRequest = z.infer<typeof requestSchema>
+
+/** A placement under construction may omit rotation (canonicalized to 0). */
+export type PlacementInput = z.input<typeof placementSchema>
+
+export function canonicalPlacement(box: PlacementInput, totalModules: number): Placement {
+  // Signed origins keep off-canvas placement editable; export performs strict bounds checks.
+  return {
+    x: Math.round(box.x),
+    y: Math.round(box.y),
+    size: Math.max(4, Math.round(box.size / totalModules)) * totalModules,
+    rotation: canonicalizeRotation(box.rotation),
+  }
+}
+
+export function recenterPlacement(box: PlacementInput, previousModules: number, nextModules: number): Placement {
+  const size = Math.max(4, Math.round(box.size / previousModules)) * nextModules
+  const offset = (box.size - size) / 2
+  return {
+    x: Math.round(box.x + offset),
+    y: Math.round(box.y + offset),
+    size,
+    rotation: canonicalizeRotation(box.rotation),
+  }
+}
+
+export function fitsMask(mask: Uint8Array, width: number, height: number, box: PlacementInput): boolean {
+  if (
+    ![box.x, box.y, box.size].every(Number.isInteger) ||
+    box.size <= 0 ||
+    box.x < 0 ||
+    box.y < 0 ||
+    box.x + box.size > width ||
+    box.y + box.size > height
+  )
+    return false
+  const size = box.size
+  const rotation = canonicalizeRotation(box.rotation)
+  if (rotation === 0) {
+    for (let y = box.y; y < box.y + size; y++)
+      for (let x = box.x; x < box.x + size; x++) if (!mask[y * width + x]) return false
+    return true
+  }
+  // Rotated square: containment is tested against the actual rotated footprint —
+  // the axis-aligned bounding box is necessary but not sufficient for irregular masks.
+  const footprint = rotatedFootprintBounds({ x: box.x, y: box.y, size, rotation }, width, height)
+  const placementBox = { x: box.x, y: box.y, size, rotation }
+  for (let y = footprint.top; y < footprint.bottom; y++) {
+    for (let x = footprint.left; x < footprint.right; x++) {
+      const local = posterToPlatePoint(x + 0.5, y + 0.5, placementBox)
+      if (!localPointInPlate(local.x, local.y, size)) continue
+      if (!mask[y * width + x]) return false
+    }
+  }
+  return true
+}

package/src/wasm.d.ts

@@ -0,0 +1,5 @@
+/** Bundlers expose Worker WASM as an asset URL in the browser or a module in Cloudflare. */
+declare module '*.wasm' {
+  const wasm: string | WebAssembly.Module
+  export default wasm
+}

package/src/worker-shim.ts

@@ -0,0 +1,15 @@
+/**
+ * Dedicated workers have no `window`, but the engine's QR decoder imports
+ * ZXing, whose PDF417 tables touch `window.BigInt` at module scope. Aliasing
+ * `window` to the worker global keeps that import alive in every bundler
+ * (Turbopack shims `window` in worker output; Vite does not). Must be the
+ * first import of the worker entry, before the engine evaluates. The check
+ * reads the property off `globalThis` so minifiers cannot fold it away, and
+ * it is a no-op on the main thread, where `window` already exists.
+ */
+
+const workerGlobal = globalThis as { window?: unknown }
+
+if (workerGlobal.window === undefined) {
+  workerGlobal.window = workerGlobal
+}