@iyulab/lowline-form 0.0.0-stage → 0.1.0

package/dist/session.js

@@ -0,0 +1,173 @@
+import { Draft, isEmpty } from './draft.js';
+export const englishStrings = {
+    decline: 'Not this',
+    fromValue: 'As before with {field} {value}',
+    fromSimilar: 'As in a similar record',
+    fromJudgement: 'Suggested from what was written',
+    fromWriting: 'From what you wrote',
+};
+/**
+ * One record being written: its draft, and what its fields show. A field's answer may be held back once, at random,
+ * to check it — `rate` is how often (one in twenty by default), drawn once per field of the record, before its answer
+ * is looked at, and only for a value the decider suggests.
+ */
+export class Session {
+    constructor(id, opened, rate = 0.05, random = Math.random, strings = englishStrings) {
+        this.id = id;
+        this.rate = rate;
+        this.random = random;
+        this.strings = strings;
+        this.drawn = new Set();
+        /** Fields whose value the form put in unasked, from the suggestion still shown. */
+        this.filled = new Set();
+        /** What filling from the person's writing offers, by field, until the person picks it or turns it down. */
+        this.written = new Map();
+        /** The judgement asked for each field, by what it reads; `null` while the host is still judging. */
+        this.judgements = new Map();
+        this.draft = new Draft(opened);
+    }
+    /**
+     * Takes a round of proposals for the form's `values` now. A field offered a value from the person's writing keeps it
+     * in view until the person picks it or turns it down.
+     */
+    apply(proposals, values) {
+        const round = { fieldStates: Object.fromEntries(this.written), prefill: {} };
+        for (const proposal of proposals) {
+            const { field, suggestion } = proposal;
+            if (!suggestion || this.written.has(field))
+                continue;
+            if (this.draw(field, suggestion))
+                continue;
+            if (this.draft.held(field) !== undefined)
+                continue;
+            // Turned down, it stays down for this record: neither shown again nor put back in.
+            if (this.draft.declined(field, suggestion))
+                continue;
+            this.draft.show(field, suggestion);
+            if (proposal.prefill && isEmpty(values[field])) {
+                round.prefill[field] = suggestion.value;
+                this.filled.add(field);
+            }
+            round.fieldStates[field] = {
+                suggestions: [suggestion.value],
+                decline: this.strings.decline,
+                ...(this.note(proposal, values) ? { note: this.note(proposal, values) } : {}),
+            };
+        }
+        return round;
+    }
+    /**
+     * The round's proposals with each field that asks for a judgement answered by the one already judged on the same
+     * values, if there is one — so a judgement stays in view while the person writes on, and is not asked for again.
+     */
+    judged(proposals) {
+        return proposals.map((proposal) => {
+            if (proposal.abstain !== 'needs-judgement')
+                return proposal;
+            const known = this.judgements.get(proposal.field);
+            return known?.reads === reads(proposal) && known.proposal ? known.proposal : proposal;
+        });
+    }
+    /**
+     * The fields of the round that ask for a judgement not asked for yet on what they read; marked as being asked. A field
+     * with nothing to read yet is left until there is something.
+     */
+    toJudge(proposals) {
+        const asking = proposals.filter((p) => p.abstain === 'needs-judgement' && (p.asks?.length ?? 0) > 0 && this.judgements.get(p.field)?.reads !== reads(p));
+        for (const p of asking)
+            this.judgements.set(p.field, { reads: reads(p), proposal: null });
+        return asking.map((p) => p.field);
+    }
+    /**
+     * Takes what the host judged for the fields `asked` — each a proposal as the round would give it; a field it gave
+     * nothing for stays as it was, and is not asked about again on the same values. A field asked for again since, on
+     * other values, keeps waiting for that one.
+     */
+    takeJudged(asked, judged) {
+        for (const before of asked) {
+            const pending = this.judgements.get(before.field);
+            if (pending?.reads !== reads(before))
+                continue;
+            const answer = judged.find((j) => j.field === before.field) ?? before;
+            this.judgements.set(before.field, { reads: pending.reads, proposal: answer });
+        }
+    }
+    /** The host could not judge the fields `asked`: they may be asked about again. */
+    notJudged(asked) {
+        for (const before of asked) {
+            if (this.judgements.get(before.field)?.reads === reads(before))
+                this.judgements.delete(before.field);
+        }
+    }
+    /**
+     * Takes what filling from the person's writing offers: each value shown as a suggestion from elsewhere, never put in
+     * on its own, in place of what the records suggest for the field. Answers what every field shows now.
+     */
+    applyFill(proposals) {
+        for (const { field, suggestion } of proposals) {
+            if (!suggestion)
+                continue;
+            this.draft.show(field, suggestion);
+            this.filled.delete(field);
+            this.written.set(field, { suggestions: [suggestion.value], decline: this.strings.decline, note: this.strings.fromWriting });
+        }
+        return Object.fromEntries(this.written);
+    }
+    /** The person picked a field's offered value: what was offered from their writing has done its part. */
+    picked(field) {
+        this.written.delete(field);
+    }
+    /**
+     * The person turned down the field's suggestion. Answers whether the form must empty the field: it holds the value
+     * the form put in unasked — saved as it is, the turned-down value would count as taken.
+     */
+    decline(field, values) {
+        const shown = this.draft.shown(field);
+        if (!this.draft.decline(field))
+            return false;
+        const empty = this.filled.has(field) && values[field] === shown?.value;
+        this.filled.delete(field);
+        this.written.delete(field);
+        return empty;
+    }
+    /** The record was saved holding `values`: what is written next starts from them. */
+    saved(values) {
+        this.draft = new Draft(values);
+        this.drawn.clear();
+        this.filled.clear();
+        this.written.clear();
+        this.judgements.clear();
+    }
+    /** Whether the field's answer is held back now — drawn the first time a checkable value is proposed for it. */
+    draw(field, suggestion) {
+        if (this.drawn.has(field))
+            return this.draft.held(field) !== undefined;
+        const checkable = (suggestion.origin ?? 'decider') === 'decider' && (suggestion.fit ?? 'exact') === 'exact';
+        if (!checkable)
+            return false;
+        this.drawn.add(field);
+        if (this.rate > 0 && this.rate <= 1 && this.random() < this.rate) {
+            this.draft.hold(field, this.rate);
+            return true;
+        }
+        return false;
+    }
+    /** Where the suggestion comes from, in words. A field's value is shown as the record holds it now. */
+    note(proposal, values) {
+        const first = proposal.basis?.[0];
+        if (proposal.layer === 'key' && first?.kind === 'value') {
+            const now = values[first.field];
+            const shown = now === undefined ? first.value : Array.isArray(now) ? now.join(', ') : now;
+            return this.strings.fromValue.replace('{field}', first.field).replace('{value}', shown);
+        }
+        if (proposal.layer === 'similar')
+            return this.strings.fromSimilar;
+        if (proposal.layer === 'judgement')
+            return this.strings.fromJudgement;
+        return undefined;
+    }
+}
+/** What a proposal asking for a judgement reads, as one text. */
+function reads(proposal) {
+    return JSON.stringify(proposal.asks ?? []);
+}

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "@iyulab/lowline-form",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "The Lowline form element: a formdown form whose decided fields are suggested from the records people confirmed, talking to a Lowline host's routes.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iyulab/lowline.git",
+    "directory": "bindings/web"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "bundle": "vite build --config vite.bundle.config.ts"
+  },
+  "dependencies": {
+    "@formdown/ui": "^0.24.0",
+    "lit": "^3.3.3"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.3",
+    "vitest": "^5.0.2",
+    "vite": "^8.3.1"
+  }
+}