ninepm 0.81.0 → 0.85.0

package/dist/qr-code.d.ts

@@ -0,0 +1,48 @@
+/** White border on every side, in modules: the QR standard's required quiet zone. */
+export declare const QR_QUIET_ZONE_MODULES = 4;
+/** Smallest printed width we promise scans, border included (spec: release-gated by print tests). */
+export declare const QR_MIN_WIDTH_MM = 25;
+/**
+ * Our chosen product floor for one module, in millimetres - not a universal scanning
+ * threshold. The printed scan fixtures are what justify it; re-measure before changing it.
+ */
+export declare const QR_MIN_MODULE_MM = 0.5;
+export interface QrMatrix {
+    /** Modules per side INCLUDING the quiet zone. */
+    size: number;
+    /** Modules per side of the symbol alone. */
+    symbolSize: number;
+    /** `modules[y][x]`, true = dark, quiet zone included. */
+    modules: boolean[][];
+}
+export type ProjectQrUnavailableReason = "not_published" | "disabled" | "service_access";
+export interface ProjectQrAddress {
+    url: string;
+    hostname: string;
+    kind: "custom_domain" | "platform";
+    isDefault: boolean;
+}
+export type ProjectQrResponse = {
+    available: true;
+    accessMode: string;
+    addresses: ProjectQrAddress[];
+} | {
+    available: false;
+    accessMode: string;
+    reason: ProjectQrUnavailableReason;
+};
+export declare function qrMatrix(url: string): QrMatrix;
+/** max(25 mm, 0.5 mm × (symbol modules per side + 8)): the 8 is the two four-module borders. */
+export declare function qrMinimumWidthMm(url: string): number;
+/**
+ * Black on white, sized only by its viewBox (one unit per module), so it prints at
+ * whatever physical width the owner chooses without resampling.
+ */
+export declare function qrSvg(url: string): string;
+/**
+ * Two module rows per text line using half blocks. LIGHT modules are drawn and dark ones
+ * left blank, so on the usual dark-background terminal the code reads dark-on-light, the
+ * polarity phone cameras expect. The size is always odd, so the last line's lower half lies
+ * past the matrix and is drawn light: a little more quiet zone, never a missing module.
+ */
+export declare function qrTerminal(url: string): string[];

package/dist/qr-code.js

@@ -0,0 +1,85 @@
+// AUTO-GENERATED by scripts/generate-cli-package.mjs from the in-repo CLI source -- do not edit.
+// Edit src/cli or src/shared instead; this is regenerated on typecheck/test/build/pack.
+// App QR codes (_specs/app-qr-codes.md): the encoder settings every surface shares.
+//
+// The server decides WHICH address a code may encode (GET /v1/sites/:id/qr); each client
+// draws it with these functions, so the dashboard, the CLI and any test produce the same
+// symbol for the same URL. Pure: no DOM, no node: imports, no packages.
+import { qrcodegen } from "./vendor/qrcodegen.js";
+/** White border on every side, in modules: the QR standard's required quiet zone. */
+export const QR_QUIET_ZONE_MODULES = 4;
+/** Smallest printed width we promise scans, border included (spec: release-gated by print tests). */
+export const QR_MIN_WIDTH_MM = 25;
+/**
+ * Our chosen product floor for one module, in millimetres - not a universal scanning
+ * threshold. The printed scan fixtures are what justify it; re-measure before changing it.
+ */
+export const QR_MIN_MODULE_MM = 0.5;
+function encode(url) {
+    const { QrCode, QrSegment } = qrcodegen;
+    // boostEcl=false: upstream otherwise raises Q to H whenever the data still fits the same
+    // version. The size would not change, but the fixed-Q contract would.
+    const code = QrCode.encodeSegments(QrSegment.makeSegments(url), QrCode.Ecc.QUARTILE, QrCode.MIN_VERSION, QrCode.MAX_VERSION, -1, false);
+    if (code.errorCorrectionLevel !== QrCode.Ecc.QUARTILE) {
+        throw new Error("QR encoder did not keep error correction at Q");
+    }
+    return code;
+}
+export function qrMatrix(url) {
+    const code = encode(url);
+    const border = QR_QUIET_ZONE_MODULES;
+    const size = code.size + border * 2;
+    const modules = [];
+    for (let y = 0; y < size; y++) {
+        const row = [];
+        for (let x = 0; x < size; x++)
+            row.push(code.getModule(x - border, y - border));
+        modules.push(row);
+    }
+    return { size, symbolSize: code.size, modules };
+}
+/** max(25 mm, 0.5 mm × (symbol modules per side + 8)): the 8 is the two four-module borders. */
+export function qrMinimumWidthMm(url) {
+    const { size } = qrMatrix(url);
+    return Math.max(QR_MIN_WIDTH_MM, QR_MIN_MODULE_MM * size);
+}
+/**
+ * Black on white, sized only by its viewBox (one unit per module), so it prints at
+ * whatever physical width the owner chooses without resampling.
+ */
+export function qrSvg(url) {
+    const { size, modules } = qrMatrix(url);
+    const parts = [];
+    modules.forEach((row, y) => {
+        row.forEach((dark, x) => {
+            if (dark)
+                parts.push(`M${x},${y}h1v1h-1z`);
+        });
+    });
+    return [
+        `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 ${size} ${size}" shape-rendering="crispEdges">`,
+        `<rect width="${size}" height="${size}" fill="#ffffff"/>`,
+        `<path d="${parts.join("")}" fill="#000000"/>`,
+        `</svg>`,
+    ].join("");
+}
+/**
+ * Two module rows per text line using half blocks. LIGHT modules are drawn and dark ones
+ * left blank, so on the usual dark-background terminal the code reads dark-on-light, the
+ * polarity phone cameras expect. The size is always odd, so the last line's lower half lies
+ * past the matrix and is drawn light: a little more quiet zone, never a missing module.
+ */
+export function qrTerminal(url) {
+    const { size, modules } = qrMatrix(url);
+    const lines = [];
+    for (let y = 0; y < size; y += 2) {
+        let line = "";
+        for (let x = 0; x < size; x++) {
+            const top = !(modules[y]?.[x] ?? false);
+            const bottom = !(modules[y + 1]?.[x] ?? false);
+            line += top && bottom ? "█" : top ? "▀" : bottom ? "▄" : " ";
+        }
+        lines.push(line);
+    }
+    return lines;
+}

package/dist/vendor/qrcodegen.d.ts

@@ -0,0 +1,93 @@
+export declare namespace qrcodegen {
+    type bit = number;
+    type byte = number;
+    type int = number;
+    export class QrCode {
+        readonly version: int;
+        readonly errorCorrectionLevel: QrCode.Ecc;
+        static encodeText(text: string, ecl: QrCode.Ecc): QrCode;
+        static encodeBinary(data: Readonly<Array<byte>>, ecl: QrCode.Ecc): QrCode;
+        static encodeSegments(segs: Readonly<Array<QrSegment>>, ecl: QrCode.Ecc, minVersion?: int, maxVersion?: int, mask?: int, boostEcl?: boolean): QrCode;
+        readonly size: int;
+        readonly mask: int;
+        private readonly modules;
+        private readonly isFunction;
+        constructor(version: int, errorCorrectionLevel: QrCode.Ecc, dataCodewords: Readonly<Array<byte>>, msk: int);
+        getModule(x: int, y: int): boolean;
+        private drawFunctionPatterns;
+        private drawFormatBits;
+        private drawVersion;
+        private drawFinderPattern;
+        private drawAlignmentPattern;
+        private setFunctionModule;
+        private addEccAndInterleave;
+        private drawCodewords;
+        private applyMask;
+        private getPenaltyScore;
+        private getAlignmentPatternPositions;
+        private static getNumRawDataModules;
+        private static getNumDataCodewords;
+        private static reedSolomonComputeDivisor;
+        private static reedSolomonComputeRemainder;
+        private static reedSolomonMultiply;
+        private finderPenaltyCountPatterns;
+        private finderPenaltyTerminateAndCount;
+        private finderPenaltyAddHistory;
+        static readonly MIN_VERSION: int;
+        static readonly MAX_VERSION: int;
+        private static readonly PENALTY_N1;
+        private static readonly PENALTY_N2;
+        private static readonly PENALTY_N3;
+        private static readonly PENALTY_N4;
+        private static readonly ECC_CODEWORDS_PER_BLOCK;
+        private static readonly NUM_ERROR_CORRECTION_BLOCKS;
+    }
+    export class QrSegment {
+        readonly mode: QrSegment.Mode;
+        readonly numChars: int;
+        private readonly bitData;
+        static makeBytes(data: Readonly<Array<byte>>): QrSegment;
+        static makeNumeric(digits: string): QrSegment;
+        static makeAlphanumeric(text: string): QrSegment;
+        static makeSegments(text: string): Array<QrSegment>;
+        static makeEci(assignVal: int): QrSegment;
+        static isNumeric(text: string): boolean;
+        static isAlphanumeric(text: string): boolean;
+        constructor(mode: QrSegment.Mode, numChars: int, bitData: Array<bit>);
+        getData(): Array<bit>;
+        static getTotalBits(segs: Readonly<Array<QrSegment>>, version: int): number;
+        private static toUtf8ByteArray;
+        private static readonly NUMERIC_REGEX;
+        private static readonly ALPHANUMERIC_REGEX;
+        private static readonly ALPHANUMERIC_CHARSET;
+    }
+    export {};
+}
+export declare namespace qrcodegen.QrCode {
+    type int = number;
+    export class Ecc {
+        readonly ordinal: int;
+        readonly formatBits: int;
+        static readonly LOW: Ecc;
+        static readonly MEDIUM: Ecc;
+        static readonly QUARTILE: Ecc;
+        static readonly HIGH: Ecc;
+        private constructor();
+    }
+    export {};
+}
+export declare namespace qrcodegen.QrSegment {
+    type int = number;
+    export class Mode {
+        readonly modeBits: int;
+        private readonly numBitsCharCount;
+        static readonly NUMERIC: Mode;
+        static readonly ALPHANUMERIC: Mode;
+        static readonly BYTE: Mode;
+        static readonly KANJI: Mode;
+        static readonly ECI: Mode;
+        private constructor();
+        numCharCountBits(ver: int): int;
+    }
+    export {};
+}