ng-form-foundry-transformers 0.4.1 → 0.5.1

package/dist/transformers/yaml/yaml-transformer.js

@@ -5,6 +5,7 @@ const yaml_1 = require("yaml");
 const thesaurus_1 = require("../../core/thesaurus");
 const infer_1 = require("../../core/infer");
 const json_schema_1 = require("../../core/json-schema");
+const merge_inferred_1 = require("../../core/merge-inferred");
 const bigint_1 = require("../../core/bigint");
 const revert_1 = require("./revert");
 /**
@@ -13,8 +14,9 @@ const revert_1 = require("./revert");
  * preserves comments, key order, and formatting by applying edits onto the parsed
  * document (see {@link applyValueToDocument}).
  *
- * The `binding` it round-trips is the parsed {@link Document}; `toSource` clones
- * it before applying, so a single `toSchema` result can serve many edits.
+ * The `binding` it round-trips is a {@link YamlBinding}; `toSource` clones the
+ * document inside it before applying, so a single `toSchema` result can serve
+ * many edits.
  *
  * With a JSON Schema in {@link YamlOptions}, the form is schema-driven; without
  * one it is inferred from the data.
@@ -27,20 +29,97 @@ exports.yamlTransformer = {
         // out-of-range integers become strings there (safe ones become plain numbers).
         const doc = (0, yaml_1.parseDocument)(source, { intAsBigInt: true });
         const data = (normalizeBigInts(doc.toJS()) ?? {});
-        const schema = options?.schema
+        const unknownKeys = options?.unknownKeys ?? 'preserve';
+        const fromJsonSchema = options?.schema
             ? (0, json_schema_1.jsonSchemaToNodeGroup)(options.schema, options.rootName, options.schemaOptions)
-            : (0, infer_1.inferNodeGroup)(data, options?.rootName);
+            : undefined;
+        const schema = fromJsonSchema && unknownKeys === 'edit'
+            ? (0, merge_inferred_1.mergeInferred)(fromJsonSchema, (0, infer_1.inferNodeGroup)(data, options?.rootName))
+            : fromJsonSchema ?? (0, infer_1.inferNodeGroup)(data, options?.rootName);
+        // Inferred leaves (the whole schema, or the uncovered slice under 'edit')
+        // pick up the document's hex/octal presentation.
+        if ((!fromJsonSchema || unknownKeys === 'edit') && doc.contents)
+            annotateRadix(doc.contents, schema);
         const labeled = options?.thesaurus ? (0, thesaurus_1.applyThesaurus)(schema, options.thesaurus) : schema;
-        return { schema: labeled, binding: doc, initialValue: data };
+        return {
+            schema: labeled,
+            // 'preserve' gates the revert on the JSON Schema's NodeGroup; 'edit' on
+            // the merged one (schema-born ≈ everything, but keys no form field can
+            // carry stay protected); 'drop' and inferred mode leave the value
+            // authoritative for the whole document.
+            binding: { doc, schema: fromJsonSchema && unknownKeys !== 'drop' ? schema : undefined },
+            initialValue: data,
+        };
     },
     toSource(value, binding) {
-        const doc = binding.clone();
-        (0, revert_1.applyValueToDocument)(doc, value);
+        const doc = binding.doc.clone();
+        (0, revert_1.applyValueToDocument)(doc, value, binding.schema);
         return String(doc);
     },
     // `satisfies` verifies conformance to the catalog contract while keeping the
     // concrete sync return types, so direct callers need no `await`.
 };
+const RADIX_BY_FORMAT = { BIN: 2, OCT: 8, HEX: 16 };
+/**
+ * Copy non-decimal integer presentation (`0x`/`0o`/`0b` literals) from the
+ * parsed document onto the inferred schema as leaf/leafList `radix` display
+ * hints — the plain-data inference cannot see them, because `toJS()` drops the
+ * scalar format. The revert needs nothing: scalars are mutated in place, so an
+ * edited value re-emits in its literal's own base. Across group-list items the
+ * first non-decimal occurrence wins — one shared item schema cannot vary the
+ * display per item. Schema-driven mode is untouched (JSON Schema has no radix
+ * vocabulary).
+ */
+function annotateRadix(node, schema) {
+    switch (schema.kind) {
+        case 'leaf': {
+            const radix = scalarRadix(node);
+            if (radix && !schema.radix)
+                schema.radix = radix;
+            return;
+        }
+        case 'leafList': {
+            if (!(0, yaml_1.isSeq)(node) || schema.radix)
+                return;
+            const radixes = node.items.map(scalarRadix);
+            if (radixes[0] && radixes.every((r) => r === radixes[0]))
+                schema.radix = radixes[0];
+            return;
+        }
+        case 'nodeGroup': {
+            if (!(0, yaml_1.isMap)(node))
+                return;
+            for (const pair of node.items) {
+                const child = schema.children[pairKey(pair.key)];
+                if (child)
+                    annotateRadix(pair.value, child);
+            }
+            return;
+        }
+        case 'nodeGroupList': {
+            if (!(0, yaml_1.isSeq)(node))
+                return;
+            for (const item of node.items)
+                annotateRadix(item, schema.type);
+            return;
+        }
+        default:
+            return; // choice/map never come out of plain-data inference
+    }
+}
+/** The display radix of a non-decimal integer scalar node, else undefined. */
+function scalarRadix(node) {
+    if (!(0, yaml_1.isScalar)(node))
+        return undefined;
+    if (typeof node.value !== 'number' && typeof node.value !== 'bigint')
+        return undefined;
+    return RADIX_BY_FORMAT[node.format ?? ''];
+}
+/** The string a key node takes as a JS object key, matching `doc.toJS()`. */
+function pairKey(key) {
+    const v = (0, yaml_1.isScalar)(key) ? key.value : key;
+    return v == null ? '' : String(v);
+}
 /**
  * Replace every BigInt from an `intAsBigInt` parse with a form-value scalar: a
  * plain `number` when it fits the safe range, otherwise its decimal string (so
@@ -52,7 +131,8 @@ function normalizeBigInts(value) {
     if (Array.isArray(value))
         return value.map(normalizeBigInts);
     if (value && typeof value === 'object') {
-        const out = {};
+        // Null prototype: a `__proto__` document key must stay a data key.
+        const out = Object.create(null);
         for (const key of Object.keys(value))
             out[key] = normalizeBigInts(value[key]);
         return out;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ng-form-foundry-transformers",
-  "version": "0.4.1",
+  "version": "0.5.1",
   "description": "Framework-agnostic Node + TypeScript catalog of source-format transformers: turn a YANG model (and more) into an ng-form-foundry schema and revert the edited form value back to the source format.",
   "keywords": [
     "ng-form-foundry",