@iyulab/lowline-form 0.1.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iyulab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -22,13 +22,16 @@ routes (`MapLowline` in .NET).
 | `rate` | How often a field's answer is held back to check it, from 0 to 1 (one in twenty by default). |
 | `strings` | The words the form shows, in the host's language. |
 
-`save()` sends the values with the account of what was shown, taken and turned down, and fires `lowline-saved`;
+`save()` sends the values with the account of what was shown, taken and turned down, and fires `lowline-saved`; a
+host that stores the record through its own API calls `settle()` after its save instead, which sends only the account
+and has the host's engine learn the record as stored (`Saved` in .NET);
 `fill(text)` offers the host model's values in their fields. A field the records cannot answer yet is judged by the
 host's model when it has one (`judge`): asked once for the values it reads, shown in the field while the person writes
 on, never put in on its own. When the routes do not answer, `lowline-unavailable` fires and the form is filled in by
 hand. Nothing is counted in the browser: the host's engine counts what it is sent.
 
-`Draft`, `Session` and `LowlineClient` are exported for a host that draws its own form.
+A host that draws its own form imports `Draft`, `Session` and `LowlineClient` from `@iyulab/lowline-form/headless`,
+which brings in neither Lit nor formdown and registers no element (the package root carries them too, with the element).
 
 The package is `@iyulab/lowline-form`, with Lit and formdown as dependencies. A page with no build step takes the one
 file in it that carries both: `dist/bundle/lowline-form.bundle.js`.

package/dist/bundle/lowline-form.bundle.js

@@ -155,8 +155,8 @@ var s = class extends Error {
 	settle(e, t, n, r) {
 		return this.post(e, "settle", {
 			id: t,
-			saved: n,
-			draft: r
+			saved: r,
+			draft: n
 		});
 	}
 	fill(e, t, n) {
@@ -11144,17 +11144,23 @@ var Fl = 300, $ = class extends Ge {
 	values() {
 		return r(this.formdown?.data ?? this.data);
 	}
-	async save() {
+	save() {
+		return this.settleWith(!0);
+	}
+	settle() {
+		return this.settleWith(!1);
+	}
+	async settleWith(e) {
 		if (!this.session || !this.form || !this.record) throw Error("lowline-form needs a form and a record to save");
-		let e = this.values(), t = await this.client.settle(this.form, this.record, e, this.session.draft);
-		return this.session.saved(e), this.dispatchEvent(new CustomEvent("lowline-saved", {
+		let t = this.values(), n = await this.client.settle(this.form, this.record, this.session.draft, e ? t : void 0);
+		return this.session.saved(t), this.dispatchEvent(new CustomEvent("lowline-saved", {
 			detail: {
-				...t,
-				values: e
+				...n,
+				values: t
 			},
 			bubbles: !0,
 			composed: !0
-		})), t;
+		})), n;
 	}
 	async fill(e) {
 		let t = this.session;

package/dist/client.d.ts

@@ -16,8 +16,11 @@ export declare class LowlineClient {
     constructor(src: string, fetcher?: typeof fetch);
     /** What to show for each open decided field of record `id`, given its values so far. */
     propose(form: string, id: string, values: Values): Promise<Proposal[]>;
-    /** Saves record `id` holding `saved`, with the draft kept while it was written. */
-    settle(form: string, id: string, saved: Values, draft: Draft): Promise<{
+    /**
+     * Settles record `id` with the draft kept while it was written: saves it holding `saved`, or — left out, for a host
+     * that stores its records through its own API and reads them back (`Saved` in .NET) — learns what the host stored.
+     */
+    settle(form: string, id: string, draft: Draft, saved?: Values): Promise<{
         id: string;
         settledAt: string;
     }>;

package/dist/client.js

@@ -20,8 +20,11 @@ export class LowlineClient {
     propose(form, id, values) {
         return this.post(form, 'propose', { id, values });
     }
-    /** Saves record `id` holding `saved`, with the draft kept while it was written. */
-    settle(form, id, saved, draft) {
+    /**
+     * Settles record `id` with the draft kept while it was written: saves it holding `saved`, or — left out, for a host
+     * that stores its records through its own API and reads them back (`Saved` in .NET) — learns what the host stored.
+     */
+    settle(form, id, draft, saved) {
         return this.post(form, 'settle', { id, saved, draft });
     }
     /** What the host's model makes of `text` for the fields of record values still empty — 404 when the host gave none. */

package/dist/headless.d.ts

@@ -0,0 +1,3 @@
+export { Draft, valuesOf, type Suggestion, type Value, type Values } from './draft.js';
+export { Session, englishStrings, type Abstain, type Basis, type FieldState, type Proposal, type Round, type Strings } from './session.js';
+export { LowlineClient, LowlineError } from './client.js';

package/dist/headless.js

@@ -0,0 +1,5 @@
+// What a host drawing its own form needs — the draft, the session and the client — without the element: nothing here
+// imports Lit or formdown, or touches the DOM, so it loads in a server or a worker too.
+export { Draft, valuesOf } from './draft.js';
+export { Session, englishStrings } from './session.js';
+export { LowlineClient, LowlineError } from './client.js';

package/dist/index.d.ts

@@ -1,4 +1,2 @@
-export { Draft, valuesOf, type Suggestion, type Value, type Values } from './draft.js';
-export { Session, englishStrings, type Abstain, type Basis, type FieldState, type Proposal, type Round, type Strings } from './session.js';
-export { LowlineClient, LowlineError } from './client.js';
+export * from './headless.js';
 export { LowlineForm } from './lowline-form.js';

package/dist/index.js

@@ -1,4 +1,2 @@
-export { Draft, valuesOf } from './draft.js';
-export { Session, englishStrings } from './session.js';
-export { LowlineClient, LowlineError } from './client.js';
+export * from './headless.js';
 export { LowlineForm } from './lowline-form.js';

package/dist/lowline-form.d.ts

@@ -47,6 +47,15 @@ export declare class LowlineForm extends LitElement {
         id: string;
         settledAt: string;
     }>;
+    /**
+     * For a host that stores the record through its own API first: sends only the account of what was shown and done,
+     * and the host's engine learns the record as the host stored it (`Saved` in .NET). What is written next starts here.
+     */
+    settle(): Promise<{
+        id: string;
+        settledAt: string;
+    }>;
+    private settleWith;
     /**
      * Fills the record from `text` — what the person wrote or a picture's description — through the host's model: each
      * value it gives is offered in its field for the person to take. Nothing is put in on its own.

package/dist/lowline-form.js

@@ -100,11 +100,21 @@ let LowlineForm = class LowlineForm extends LitElement {
         return valuesOf(this.formdown?.data ?? this.data);
     }
     /** Saves the record as it stands, with the account of what was shown and done; what is written next starts here. */
-    async save() {
+    save() {
+        return this.settleWith(true);
+    }
+    /**
+     * For a host that stores the record through its own API first: sends only the account of what was shown and done,
+     * and the host's engine learns the record as the host stored it (`Saved` in .NET). What is written next starts here.
+     */
+    settle() {
+        return this.settleWith(false);
+    }
+    async settleWith(sendValues) {
         if (!this.session || !this.form || !this.record)
             throw new Error('lowline-form needs a form and a record to save');
         const values = this.values();
-        const saved = await this.client.settle(this.form, this.record, values, this.session.draft);
+        const saved = await this.client.settle(this.form, this.record, this.session.draft, sendValues ? values : undefined);
         this.session.saved(values);
         this.dispatchEvent(new CustomEvent('lowline-saved', { detail: { ...saved, values }, bubbles: true, composed: true }));
         return saved;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iyulab/lowline-form",
-  "version": "0.1.0",
+  "version": "0.3.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": {
@@ -15,8 +15,17 @@
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
+    },
+    "./headless": {
+      "types": "./dist/headless.d.ts",
+      "import": "./dist/headless.js"
     }
   },
+  "sideEffects": [
+    "./dist/index.js",
+    "./dist/lowline-form.js",
+    "./dist/bundle/*"
+  ],
   "files": [
     "dist"
   ],