@google-cloud/kcmd 0.0.0-stage → 0.1.0

package/build/ts/kcmd/semantic/yaml_options.d.ts

@@ -0,0 +1,6 @@
+import * as yaml from 'yaml';
+export declare const YAML_OPTIONS: {
+    readonly resolveKnownTags: false;
+    readonly logLevel: "error";
+};
+export declare function parseLeniently(text: string): yaml.Document.Parsed;

package/build/ts/kcmd/semantic/yaml_options.js

@@ -0,0 +1,58 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.YAML_OPTIONS = void 0;
+exports.parseLeniently = parseLeniently;
+const yaml = __importStar(require("yaml"));
+// How kcmd parses a model or profile document. `resolveKnownTags: false` keeps
+// YAML-only tags (`!!timestamp`, `!!binary`) as the text written instead of
+// turning them into Date or Uint8Array, and reads `!!set` as a mapping with
+// null values, so custom `ai_context` members with no JSON counterpart stay
+// text. `logLevel: 'error'` keeps unresolved-tag warnings off stderr. The
+// loader, the profile reader and the layout all parse with these, so a value
+// means the same thing to each.
+exports.YAML_OPTIONS = { resolveKnownTags: false, logLevel: 'error' };
+// Parses `text` with YAML_OPTIONS and keeps what parses when the text has a
+// YAML error, such as a bad indent. A key set twice is not an error here, and
+// its last value is kept. An alias whose anchor is not set reads as null. A
+// reader that only looks values up uses this, so a model file the load
+// rejects still gives them. The load reports the error.
+function parseLeniently(text) {
+    const doc = yaml.parseDocument(text, { ...exports.YAML_OPTIONS, uniqueKeys: false });
+    yaml.visit(doc, {
+        Alias: (_, alias) => alias.resolve(doc) ? undefined : doc.createNode(null),
+    });
+    return doc;
+}

package/build/ts/kcmd/semantic/yaml_update.d.ts

@@ -0,0 +1,26 @@
+import * as yaml from 'yaml';
+/**
+ * Parses `text` for `updateText`. A JSON file, which is one flow mapping, is
+ * first rewritten as block YAML, which the returned `text` holds.
+ */
+export declare function parseForUpdate(text: string): {
+    document: yaml.Document.Parsed;
+    text: string;
+};
+/**
+ * Maps each object and array in `value` to the node it was copied from.
+ * `value` must be a plain copy of `node`.
+ */
+export declare function linkNodes(value: unknown, node: unknown, links?: Map<object, yaml.Node>): Map<object, yaml.Node>;
+/**
+ * Returns `text`, which `doc` parses, changed to hold `value`. An object or
+ * array keeps the node `links` maps it to, and any other value keeps the node
+ * under the same key, or the list item with the same `name` or value. A kept
+ * node whose value stays keeps its text and the comments and blank lines
+ * around it. A changed scalar keeps its quoting, and a removed item takes its
+ * comments and the blank lines above it. A flow collection over several lines
+ * that changes is written again in block style. A value that would be written
+ * as a block scalar that keeps its final line breaks, as `|+` does, is
+ * double-quoted instead.
+ */
+export declare function updateText(text: string, doc: yaml.Document, value: unknown, links: ReadonlyMap<object, yaml.Node>): string;