@lpdfio/lpdf 0.18.0 → 0.20.0

package/README.md

@@ -56,6 +56,10 @@ To stay on one engine and still get this package's fixes, use a tilde range in `
 
 [lpdf.io/docs/js](https://lpdf.io/docs/js)
 
+## Issues
+
+Report bugs and request features at [github.com/lpdfio/lpdf/issues](https://github.com/lpdfio/lpdf/issues), the one tracker for the engine, the SDKs and the VS Code extension. Pull requests are not accepted.
+
 --
 
 Dual-licensed: Community License (free) and Commercial License (paid). See [LICENSE](LICENSE) for full terms.

package/dist/browser.js

@@ -203,6 +203,20 @@ var LpdfEngine = class {
   }
 };
 if (Symbol.dispose) LpdfEngine.prototype[Symbol.dispose] = LpdfEngine.prototype.free;
+function check_license(token, now_unix) {
+  let deferred2_0;
+  let deferred2_1;
+  try {
+    const ptr0 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.check_license(ptr0, len0, now_unix);
+    deferred2_0 = ret[0];
+    deferred2_1 = ret[1];
+    return getStringFromWasm0(ret[0], ret[1]);
+  } finally {
+    wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+  }
+}
 function __wbg_get_imports() {
   const import0 = {
     __proto__: null,
@@ -380,6 +394,9 @@ async function __wbg_init(module_or_path) {
 
 // src/browser.ts
 var NoAttr = null;
+function nowUnix() {
+  return BigInt(Math.floor(Date.now() / 1e3));
+}
 async function initLpdf(wasmSource, licenseKey = "") {
   await __wbg_init(wasmSource);
   const fontMap = /* @__PURE__ */ new Map();
@@ -391,8 +408,12 @@ async function initLpdf(wasmSource, licenseKey = "") {
     loadImage(name, bytes) {
       imageMap.set(name, bytes);
     },
+    checkLicenseKey(key) {
+      return JSON.parse(check_license(key ?? licenseKey, nowUnix()));
+    },
     async render(input, callOptions = {}) {
       const engine = new LpdfEngine(licenseKey);
+      engine.set_now(nowUnix());
       for (const [name, bytes] of fontMap) {
         engine.load_font(name, bytes);
       }

package/dist/engine.d.ts

@@ -1,5 +1,27 @@
 import type { RenderOptions } from './_shared';
 import type { PdfDocument } from './kit';
+/** How a license key stands with this build of the engine. */
+export type LicenseStatus = 'licensed' | 'no_key' | 'expired' | 'version_mismatch' | 'wrong_product' | 'unknown_key' | 'bad_signature' | 'malformed';
+/**
+ * What the engine makes of a license key — see {@link PdfEngine.checkLicenseKey}.
+ *
+ * Everything but `status` is present only once the key's signature verified, so an expired or
+ * wrong-version key still names its license while an unreadable one says nothing further: an
+ * unverified token's contents are its author's claims, not facts.
+ */
+export interface LicenseCheck {
+    status: LicenseStatus;
+    /** Which Codesense product the key was issued for. */
+    product?: string;
+    /** `community`, `professional` or `enterprise`. */
+    tier?: string;
+    /** When the key stops validating, ISO 8601 UTC. Absent on a version-locked key. */
+    expires?: string;
+    /** The license number, as the customer reads it: `L-7K3M9Q`. */
+    license?: string;
+    /** Which key this is on its license — 1, 2, 3 in issue order. */
+    key?: number;
+}
 /** Thrown when the lpdf engine returns a layout or parse error. */
 export declare class LpdfRenderError extends Error {
     constructor(message: string);
@@ -35,6 +57,18 @@ export declare class PdfEngine {
      * Set the license key. Returns `this` for chaining.
      */
     setLicenseKey(key: string): this;
+    /**
+     * Ask the engine what a license key is: valid, expired, for another product, and which
+     * license and key it is.
+     *
+     * This is the engine's own verdict, from the same code a render runs — so `licensed` here
+     * means PDFs come out without the attribution line here. A key the portal considers perfectly
+     * good still reads `unknown_key` in a build that does not trust the key it was signed with,
+     * which is the answer worth having.
+     *
+     * @param key - The key to check. Defaults to the one set on this engine.
+     */
+    checkLicenseKey(key?: string): LicenseCheck;
     /**
      * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
      * Call before `render`. Returns `this` for chaining.

package/dist/engine.js

@@ -8,6 +8,18 @@ const node_fs_1 = require("node:fs");
 // eslint-disable-next-line @typescript-eslint/no-require-imports
 const wasmModule = require('./wasm/lpdf.js');
 const WasmEngine = wasmModule.LpdfEngine;
+/**
+ * The clock the engine checks a key's expiry against.
+ *
+ * WebAssembly has no clock of its own, so an engine that is not told the time skips the expiry
+ * check altogether — which is how an expired key used to render without the attribution line.
+ *
+ * A `bigint`, because the engine takes the seconds as an `i64` and wasm-bindgen accepts nothing
+ * narrower on that boundary.
+ */
+function nowUnix() {
+    return BigInt(Math.floor(Date.now() / 1000));
+}
 /** Thrown when the lpdf engine returns a layout or parse error. */
 class LpdfRenderError extends Error {
     constructor(message) {
@@ -32,6 +44,21 @@ class PdfEngine {
         this._licenseKey = key;
         return this;
     }
+    /**
+     * Ask the engine what a license key is: valid, expired, for another product, and which
+     * license and key it is.
+     *
+     * This is the engine's own verdict, from the same code a render runs — so `licensed` here
+     * means PDFs come out without the attribution line here. A key the portal considers perfectly
+     * good still reads `unknown_key` in a build that does not trust the key it was signed with,
+     * which is the answer worth having.
+     *
+     * @param key - The key to check. Defaults to the one set on this engine.
+     */
+    checkLicenseKey(key) {
+        this._throwIfDisposed();
+        return JSON.parse(wasmModule.check_license(key ?? this._licenseKey, nowUnix()));
+    }
     /**
      * Register raw TTF/OTF bytes for a custom font name used in `<font src="…">`.
      * Call before `render`. Returns `this` for chaining.
@@ -83,6 +110,9 @@ class PdfEngine {
     async render(input, callOptions = {}) {
         this._throwIfDisposed();
         const engine = new WasmEngine(this._licenseKey);
+        // Without a clock the engine cannot check the key's expiry, and an expired key renders as
+        // though it were current.
+        engine.set_now(nowUnix());
         if (callOptions.createdOn) {
             engine.set_created_on(callOptions.createdOn);
         }

package/dist/wasm/lpdf-web.js

@@ -205,6 +205,42 @@ export class LpdfEngine {
 }
 if (Symbol.dispose) LpdfEngine.prototype[Symbol.dispose] = LpdfEngine.prototype.free;
 
+/**
+ * What this build of the engine makes of a license key, as JSON.
+ *
+ * ```json
+ * { "status": "licensed", "product": "lpdf", "tier": "professional",
+ *   "expires": "2027-09-19T00:00:00Z", "license": "L-7K3M9Q", "key": 3 }
+ * ```
+ *
+ * `status` is one of `licensed`, `no_key`, `expired`, `version_mismatch`, `wrong_product`,
+ * `unknown_key`, `bad_signature` or `malformed`. The remaining fields appear only once the
+ * signature verified — see [`license::report_json`].
+ *
+ * A free function, not a method: asking what a key is should not require building an engine.
+ * `now_unix` is the caller's clock in seconds, since wasm has none; `0` skips the expiry check.
+ *
+ * The answer is this build's. An engine older than the key, or one built for another
+ * environment, answers `unknown_key` — which is the useful part, not a caveat.
+ * @param {string} token
+ * @param {bigint} now_unix
+ * @returns {string}
+ */
+export function check_license(token, now_unix) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.check_license(ptr0, len0, now_unix);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+
 /**
  * Generate SDK source code from one or more bare Lpdf XML elements (a fragment).
  *

package/dist/wasm/lpdf.js

@@ -206,6 +206,43 @@ class LpdfEngine {
 if (Symbol.dispose) LpdfEngine.prototype[Symbol.dispose] = LpdfEngine.prototype.free;
 exports.LpdfEngine = LpdfEngine;
 
+/**
+ * What this build of the engine makes of a license key, as JSON.
+ *
+ * ```json
+ * { "status": "licensed", "product": "lpdf", "tier": "professional",
+ *   "expires": "2027-09-19T00:00:00Z", "license": "L-7K3M9Q", "key": 3 }
+ * ```
+ *
+ * `status` is one of `licensed`, `no_key`, `expired`, `version_mismatch`, `wrong_product`,
+ * `unknown_key`, `bad_signature` or `malformed`. The remaining fields appear only once the
+ * signature verified — see [`license::report_json`].
+ *
+ * A free function, not a method: asking what a key is should not require building an engine.
+ * `now_unix` is the caller's clock in seconds, since wasm has none; `0` skips the expiry check.
+ *
+ * The answer is this build's. An engine older than the key, or one built for another
+ * environment, answers `unknown_key` — which is the useful part, not a caveat.
+ * @param {string} token
+ * @param {bigint} now_unix
+ * @returns {string}
+ */
+function check_license(token, now_unix) {
+    let deferred2_0;
+    let deferred2_1;
+    try {
+        const ptr0 = passStringToWasm0(token, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.check_license(ptr0, len0, now_unix);
+        deferred2_0 = ret[0];
+        deferred2_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+    }
+}
+exports.check_license = check_license;
+
 /**
  * Generate SDK source code from one or more bare Lpdf XML elements (a fragment).
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lpdfio/lpdf",
-  "version": "0.18.0",
+  "version": "0.20.0",
   "description": "Node.js SDK for Lpdf — PDF as Code on every platform. You describe a document as code or XML. Lpdf renders a compact, pixel-perfect PDF — identical across platforms.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -26,6 +26,9 @@
     "type": "git",
     "url": "https://github.com/lpdfio/lpdf-js"
   },
+  "bugs": {
+    "url": "https://github.com/lpdfio/lpdf/issues"
+  },
   "keywords": [
     "pdf",
     "wasm",