@amritk/nish-x86_64-linux 0.28.0 → 0.29.0

package/std/json-typed.ts

@@ -54,6 +54,40 @@
  * A map is emptied and filled in the input's order, and every map of one
  * decoding takes at most `maxMapKeys` keys between them.
  *
+ * **Which keys were given.** An optional field's missing key and a key given
+ * the field's initializer leave the same value; the `presence` option tells
+ * them apart. It names, for a field, a `boolean` field of the same class that
+ * each decoding sets to whether the input gave that field's key — true for a
+ * key given `null` too:
+ *
+ *     class UserPatch {
+ *       static readonly json = { optional: ["name", "email"], presence: { name: "hasName", email: "hasEmail" } };
+ *       name: string = "";
+ *       email: string | null = null;
+ *       hasName: boolean = false;
+ *       hasEmail: boolean = false;
+ *     }
+ *
+ * Any field can be recorded, of any kind and optional or not. A presence
+ * field is off the wire: no key reads it, encoding leaves it out, and no option
+ * renames it, makes it optional or records it. It is set when the object
+ * closes, from the flag the decoder already keeps per field to find a
+ * duplicate or a missing key, so recording costs one store per recorded field
+ * and allocates nothing, and a class that records nothing compiles to the code
+ * it did before. Each object sets its own, so a nested class or an array
+ * element answers for its own keys. A decoding that fails may set some of
+ * them and not others (when the input is not an object, none), so read them
+ * only when `jsonDecode` answered `JSON_DECODE_OK`.
+ *
+ * **A merge patch (RFC 7396)** is that option's use: a patch class whose
+ * every field is optional and recorded, decoded and then applied a field at a
+ * time — a recorded key replaces its member, `null` on a `| null` field
+ * removes it, an object field is applied the same way one level down, and an
+ * array is replaced whole. `null` on a field that is not `| null` is
+ * `JSON_DECODE_TYPE`, so a patch that removes what the type cannot lose is
+ * refused before any of it is applied. `examples/merge-patch.ts` is the
+ * recipe in full.
+ *
  * **Errors are sticky codes**, as the tokenizer's and the writer's are. The
  * first error sets `failed` to a negative code — a `JSON_DECODE_*` code here,
  * or the tokenizer's own `JSON_TOK_ERR_*` code when the text is not JSON or

package/std/json.ts

@@ -1791,16 +1791,45 @@ const jsonWriterPutDigits64 = (w: JsonWriter, v: i64): boolean => {
 }
 
 /**
- * The digits `${v}` spells for a finite `v`, at the cursor. They are a string
+ * The digits `${v}` spells for a finite `v`, in `buf` from `at`: the new end,
+ * or -1, with nothing written, when `at` is negative or they do not fit —
+ * `jsonWriterPutText`'s rule. Natively the compiler replaces the one call to
+ * it with the runtime's `nish_json_put_f64` (`src/kernels.ts`), which formats
+ * into the stack and copies, so no string is built at all; that is why the
+ * walk takes the array and the cursor rather than the writer.
+ *
+ * As written, which is what Node and `--emit-ts` run, the digits are a string
  * the runtime builds, and nothing holds it once its bytes are copied, so the
  * function's automatic arena scope (LANGUAGE.md, "Memory model", item 2)
  * gives it back before the call returns: a loop of `f64` writes keeps
- * `Arena.used()` flat like every other write, and `tests/link/std_json_writer`
- * measures it. The scope is the compiler's rather than a `using a = arena()`
- * block because this module also runs under Node, which `tests/run.js` holds
- * to `JSON.stringify`, and Node 22 does not parse `using`.
+ * `Arena.used()` flat like every other write either way, and
+ * `tests/link/std_json_writer` measures it. The scope is the compiler's rather
+ * than a `using a = arena()` block because this module also runs under Node,
+ * which `tests/run.js` holds to `JSON.stringify`, and Node 22 does not parse
+ * `using`.
  */
-const jsonWriterPutF64 = (w: JsonWriter, v: f64): boolean => jsonWriterPutText(w, `${v}`)
+const jsonPutF64Walk = (buf: u8[], at: i32, v: f64): i32 => {
+  const text: string = `${v}`
+  const n: i32 = toI32(text.length)
+  if (at < 0 || at > toI32(buf.length) - n) {
+    return -1
+  }
+  for (let k: i32 = 0; k < n && at + k < toI32(buf.length); k += 1) {
+    buf[at + k] = toU8(text.charCodeAt(k))
+  }
+  return at + n
+}
+
+/** The digits `${v}` spells for a finite `v`, at the cursor; all of them or, with `JSON_WRITE_FULL`, none. */
+const jsonWriterPutF64 = (w: JsonWriter, v: f64): boolean => {
+  const stop: i32 = jsonPutF64Walk(w.buf, w.end, v)
+  if (stop < 0) {
+    w.failed = JSON_WRITE_FULL
+    return false
+  }
+  w.end = stop
+  return true
+}
 
 /**
  * `s` as `JSON.stringify(s)` writes it — quoted, with the escapes