lingotweaker-wasm 0.2.4 → 0.2.6

package/README.md

@@ -59,6 +59,47 @@ Or, from an ES module: `import { LtEngine } from "lingotweaker-wasm/node"`.
 `today` is required in practice: WebAssembly has no clock, so the date is
 passed in and pinned for the engine's date filters.
 
+## Language detection
+
+`detect_json` is a free function, not an `LtEngine` method: choosing the
+language is what picks the engine, so you ask before any engine exists. It
+needs no data pack — the identifier model and the Nordum marker list are
+embedded in the wasm binary.
+
+```js
+import init, { detect_json, LtEngine } from "lingotweaker-wasm";
+
+await init();
+
+const { resolved, detected, candidates } = JSON.parse(
+  detect_json("Jag arbetar inte i dag, men jag kommer hem efter jobbet."),
+);
+// resolved: "sv"  detected: {language: "sv", confidence: 0.99, source: "model"}
+// candidates: the five best-scoring languages, best first
+
+const engine = new LtEngine(
+  resolved ?? "en-US",
+  pack,
+  JSON.stringify({ today: new Date().toISOString() }),
+);
+```
+
+`resolved` is `null` when there is not enough evidence to answer — that is a
+normal outcome, not an error, and the caller keeps the language it already had.
+`detected.source` says which layer decided: `"lexicon"` for a word no other
+language we ship contains (this is how Nordum is detected), `"model"` for the
+statistical model.
+
+Detection is deliberately conservative on short fragments, which is what an
+editor sees. The optional second argument overrides the thresholds:
+
+```js
+detect_json(text, JSON.stringify({ minChars: 40, minConfidence: 0.3, minMargin: 2 }));
+```
+
+Each field defaults to the engine default, so `{}` is the same call as no
+argument.
+
 ## Data
 
 The package ships **code only** and depends on the code-only

package/node/lt_wasm.d.ts

@@ -55,4 +55,24 @@ export class LtEngine {
     variant(): string | undefined;
 }
 
+/**
+ * Detect the language of `text` and return the decision as JSON:
+ * `{"resolved":"sv","detected":{…},"candidates":[…]}`.
+ *
+ * `gates` is an optional JSON object overriding the thresholds
+ * (`{"minChars":20,"minConfidence":0.6,"minMargin":1.5}`); absent means
+ * [`Gates::default()`].
+ *
+ * `resolved` is `null` when the gates abstain — the text is too short, too
+ * ambiguous, or carries no marker. That is a normal outcome, not an error: the
+ * caller keeps whatever language it was already using.
+ *
+ * ```js
+ * import init, { detect_json } from "./pkg/lt_wasm.js";
+ * await init();
+ * JSON.parse(detect_json("Jag kommer hem efter jobbet.")).resolved; // "sv"
+ * ```
+ */
+export function detect_json(text: string, gates?: string | null): string;
+
 export function start(): void;

package/node/lt_wasm.js

@@ -188,6 +188,51 @@ class LtEngine {
 if (Symbol.dispose) LtEngine.prototype[Symbol.dispose] = LtEngine.prototype.free;
 exports.LtEngine = LtEngine;
 
+/**
+ * Detect the language of `text` and return the decision as JSON:
+ * `{"resolved":"sv","detected":{…},"candidates":[…]}`.
+ *
+ * `gates` is an optional JSON object overriding the thresholds
+ * (`{"minChars":20,"minConfidence":0.6,"minMargin":1.5}`); absent means
+ * [`Gates::default()`].
+ *
+ * `resolved` is `null` when the gates abstain — the text is too short, too
+ * ambiguous, or carries no marker. That is a normal outcome, not an error: the
+ * caller keeps whatever language it was already using.
+ *
+ * ```js
+ * import init, { detect_json } from "./pkg/lt_wasm.js";
+ * await init();
+ * JSON.parse(detect_json("Jag kommer hem efter jobbet.")).resolved; // "sv"
+ * ```
+ * @param {string} text
+ * @param {string | null} [gates]
+ * @returns {string}
+ */
+function detect_json(text, gates) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(gates) ? 0 : passStringToWasm0(gates, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.detect_json(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+exports.detect_json = detect_json;
+
 function start() {
     wasm.start();
 }

package/node/lt_wasm_bg.wasm.d.ts

@@ -2,6 +2,7 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_ltengine_free: (a: number, b: number) => void;
+export const detect_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const ltengine_active_rule_count: (a: number) => number;
 export const ltengine_check_json: (a: number, b: number, c: number) => [number, number, number, number];
 export const ltengine_check_matches_json: (a: number, b: number, c: number) => [number, number, number, number];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lingotweaker-wasm",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "LingoTweaker proofreading engine compiled to WebAssembly (browser and Node)",
   "license": "LGPL-2.1-or-later",
   "repository": {
@@ -22,7 +22,7 @@
   "module": "./web/lt_wasm.js",
   "types": "./web/lt_wasm.d.ts",
   "dependencies": {
-    "lingotweaker-data": "0.2.4"
+    "lingotweaker-data": "0.2.6"
   },
   "exports": {
     ".": {

package/web/lt_wasm.d.ts

@@ -55,6 +55,26 @@ export class LtEngine {
     variant(): string | undefined;
 }
 
+/**
+ * Detect the language of `text` and return the decision as JSON:
+ * `{"resolved":"sv","detected":{…},"candidates":[…]}`.
+ *
+ * `gates` is an optional JSON object overriding the thresholds
+ * (`{"minChars":20,"minConfidence":0.6,"minMargin":1.5}`); absent means
+ * [`Gates::default()`].
+ *
+ * `resolved` is `null` when the gates abstain — the text is too short, too
+ * ambiguous, or carries no marker. That is a normal outcome, not an error: the
+ * caller keeps whatever language it was already using.
+ *
+ * ```js
+ * import init, { detect_json } from "./pkg/lt_wasm.js";
+ * await init();
+ * JSON.parse(detect_json("Jag kommer hem efter jobbet.")).resolved; // "sv"
+ * ```
+ */
+export function detect_json(text: string, gates?: string | null): string;
+
 export function start(): void;
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
@@ -62,6 +82,7 @@ export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembl
 export interface InitOutput {
     readonly memory: WebAssembly.Memory;
     readonly __wbg_ltengine_free: (a: number, b: number) => void;
+    readonly detect_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
     readonly ltengine_active_rule_count: (a: number) => number;
     readonly ltengine_check_json: (a: number, b: number, c: number) => [number, number, number, number];
     readonly ltengine_check_matches_json: (a: number, b: number, c: number) => [number, number, number, number];

package/web/lt_wasm.js

@@ -187,6 +187,50 @@ export class LtEngine {
 }
 if (Symbol.dispose) LtEngine.prototype[Symbol.dispose] = LtEngine.prototype.free;
 
+/**
+ * Detect the language of `text` and return the decision as JSON:
+ * `{"resolved":"sv","detected":{…},"candidates":[…]}`.
+ *
+ * `gates` is an optional JSON object overriding the thresholds
+ * (`{"minChars":20,"minConfidence":0.6,"minMargin":1.5}`); absent means
+ * [`Gates::default()`].
+ *
+ * `resolved` is `null` when the gates abstain — the text is too short, too
+ * ambiguous, or carries no marker. That is a normal outcome, not an error: the
+ * caller keeps whatever language it was already using.
+ *
+ * ```js
+ * import init, { detect_json } from "./pkg/lt_wasm.js";
+ * await init();
+ * JSON.parse(detect_json("Jag kommer hem efter jobbet.")).resolved; // "sv"
+ * ```
+ * @param {string} text
+ * @param {string | null} [gates]
+ * @returns {string}
+ */
+export function detect_json(text, gates) {
+    let deferred4_0;
+    let deferred4_1;
+    try {
+        const ptr0 = passStringToWasm0(text, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        var ptr1 = isLikeNone(gates) ? 0 : passStringToWasm0(gates, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        var len1 = WASM_VECTOR_LEN;
+        const ret = wasm.detect_json(ptr0, len0, ptr1, len1);
+        var ptr3 = ret[0];
+        var len3 = ret[1];
+        if (ret[3]) {
+            ptr3 = 0; len3 = 0;
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        deferred4_0 = ptr3;
+        deferred4_1 = len3;
+        return getStringFromWasm0(ptr3, len3);
+    } finally {
+        wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+    }
+}
+
 export function start() {
     wasm.start();
 }

package/web/lt_wasm_bg.wasm.d.ts

@@ -2,6 +2,7 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_ltengine_free: (a: number, b: number) => void;
+export const detect_json: (a: number, b: number, c: number, d: number) => [number, number, number, number];
 export const ltengine_active_rule_count: (a: number) => number;
 export const ltengine_check_json: (a: number, b: number, c: number) => [number, number, number, number];
 export const ltengine_check_matches_json: (a: number, b: number, c: number) => [number, number, number, number];