@wildwinter/toolkit 0.2.3 → 0.2.5

package/dist/extensions.cjs

@@ -24,7 +24,7 @@ var HOSTS = {
   }
 };
 var SCALAR_TYPES = ["text", "multiline", "number", "boolean", "enum", "flags", "quality"];
-var VALUE_TYPES = [...SCALAR_TYPES, "reference", "record", "map", "list"];
+var VALUE_TYPES = [...SCALAR_TYPES, "reference", "pick", "record", "map", "list"];
 function parseSource(text) {
   const body = text.charCodeAt(0) === 65279 ? text.slice(1) : text;
   return JSON5__default.default.parse(body);
@@ -112,6 +112,26 @@ function valueProblems(decl, value, ctx = {}, path = "") {
         out.push(err("no-such-node", path, `${where(path)} names ${decl.to} "${value}", which does not exist`));
       }
       break;
+    case "pick": {
+      if (typeof value !== "string") {
+        wrong("one of its choices, as text");
+        break;
+      }
+      if (value === "") break;
+      const sources = decl.from ?? [];
+      const holding = sources.filter((s) => sourceHolds(s, value, ctx) === true);
+      if (holding.length > 1) {
+        out.push({
+          severity: "warning",
+          code: "pick-ambiguous",
+          path,
+          message: `${where(path)} is "${value}", which is ${holding.map(sourceWord).join(" and ")}`
+        });
+      } else if (holding.length === 0 && sources.every((s) => sourceHolds(s, value, ctx) !== void 0)) {
+        out.push(err("not-a-choice", path, `${where(path)} is "${value}", which is not one of its choices`));
+      }
+      break;
+    }
     case "record":
       if (!isObject(value)) {
         wrong("an object");
@@ -191,11 +211,69 @@ function entryProblems(target, entry, ctx = {}, path = "") {
   }
   return fieldsProblems(target.fields ?? [], entry, ctx, path);
 }
+function sourceHolds(source, value, ctx) {
+  if ("words" in source) return Array.isArray(source.words) && source.words.includes(value);
+  if ("to" in source) return ctx.exists === void 0 ? void 0 : ctx.exists(source.to, value);
+  if ("list" in source) return ctx.list === void 0 ? void 0 : (ctx.list(source.list) ?? []).includes(value);
+  return false;
+}
+function sourceWord(source) {
+  if ("words" in source) return "a fixed word";
+  if ("to" in source) return source.to === "cast" ? "a cast member" : `a ${source.to}`;
+  return `an entry of the list "${source.list}"`;
+}
+function pickChoices(decl, src) {
+  const out = [];
+  for (const source of decl.from ?? []) {
+    if ("words" in source) {
+      for (const w of source.words ?? []) if (typeof w === "string" && w !== "") out.push({ value: w, label: w, source });
+    } else if ("to" in source) {
+      for (const n of src.nodes?.(source.to) ?? []) if (n.id !== "") out.push({ value: n.id, label: n.label ?? n.id, source });
+    } else if ("list" in source) {
+      for (const e of src.list?.(source.list) ?? []) if (e !== "") out.push({ value: e, label: e, source });
+    }
+  }
+  return out;
+}
+function pickClashes(decl, src, path = "") {
+  const by = /* @__PURE__ */ new Map();
+  for (const c of pickChoices(decl, src)) {
+    const held = by.get(c.value) ?? [];
+    if (!held.includes(c.source)) held.push(c.source);
+    by.set(c.value, held);
+  }
+  const out = [];
+  for (const [name, sources] of by) {
+    if (sources.length < 2) continue;
+    out.push({
+      severity: "warning",
+      code: "pick-clash",
+      path,
+      options: [name],
+      message: `"${name}" is ${sources.map(sourceWord).join(" and ")}, so a value naming it is ambiguous`
+    });
+  }
+  return out;
+}
+function pickLists(projectTarget, projectEntry) {
+  return (name) => {
+    const field = (projectTarget?.fields ?? []).find((f) => f.name === name);
+    if (field === void 0 || !isTextList(field)) return void 0;
+    const held = projectEntry !== void 0 && own(projectEntry, name) ? projectEntry[name] : void 0;
+    const value = Array.isArray(held) ? held : defaultOf(field);
+    return Array.isArray(value) ? value.filter((v) => typeof v === "string") : [];
+  };
+}
+function isTextList(decl) {
+  return decl.type === "list" && decl.id === void 0 && decl.of?.type === "text";
+}
 function defaultOf(decl) {
   if (decl.default !== void 0) return decl.default;
   switch (decl.type) {
     case "reference":
       return "";
+    case "pick":
+      return "";
     case "record":
       return Object.fromEntries((decl.fields ?? []).map((f) => [f.name, defaultOf(f)]));
     case "map":
@@ -288,7 +366,7 @@ function renameStages(target, entry) {
 var ID = /^[a-z][a-z0-9-]*$/;
 var VERSION = /^\d+\.\d+\.\d+$/;
 var NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
-var TYPE_KEYS = ["type", "values", "stages", "renamedStages", "to", "fields", "key", "of", "id", "min", "max", "valueHelp", "default"];
+var TYPE_KEYS = ["type", "values", "stages", "renamedStages", "to", "from", "fields", "key", "of", "id", "min", "max", "valueHelp", "default"];
 var FIELD_KEYS = /* @__PURE__ */ new Set([...TYPE_KEYS, "name", "label", "help", "required", "group", "editorOnly"]);
 var CLAIM_KEYS = /* @__PURE__ */ new Set([...TYPE_KEYS, "setting", "label", "help", "required"]);
 var BARE_KEYS = new Set(TYPE_KEYS);
@@ -338,9 +416,80 @@ function manifestProblems(manifest) {
       }
       targetProblems(host, kind, target, kindPath, settings, out);
     }
+    pickListProblems(kinds, hostPath, out);
   }
   return out;
 }
+function pickSourcesSound(host, from, path, out) {
+  if (!Array.isArray(from) || from.length === 0) {
+    out.push(err2("pick-from", path, 'a pick lists its sources in "from": { "words": [...] }, { "to": a node kind }, or { "list": a project list }'));
+    return false;
+  }
+  let sound = true;
+  from.forEach((s, i) => {
+    const at = atIndex(path, i);
+    const keys = isObject(s) ? Object.keys(s).filter((k) => k === "words" || k === "to" || k === "list") : [];
+    if (!isObject(s) || keys.length !== 1) {
+      out.push(err2("pick-source", at, 'a source is one of { "words": [...] }, { "to": a node kind }, { "list": a project list }'));
+      sound = false;
+      return;
+    }
+    unknownKeys(s, new Set(keys), at, out);
+    if (keys[0] === "words") {
+      const words = s["words"];
+      const seen = /* @__PURE__ */ new Set();
+      if (!Array.isArray(words) || words.length === 0) {
+        out.push(err2("pick-words", atKey(at, "words"), "fixed words are a list of at least one"));
+        sound = false;
+        return;
+      }
+      words.forEach((w, j) => {
+        if (typeof w !== "string" || w.trim() === "") {
+          out.push(err2("value-empty", atIndex(atKey(at, "words"), j), "a word has a name"));
+          sound = false;
+        } else if (seen.has(w)) {
+          out.push(err2("value-duplicate", atIndex(atKey(at, "words"), j), `"${w}" is listed twice`));
+          sound = false;
+        } else seen.add(w);
+      });
+    } else if (keys[0] === "to") {
+      if (typeof s["to"] !== "string" || !HOSTS[host].references.includes(s["to"])) {
+        out.push(err2("reference-to", atKey(at, "to"), `a source's nodes are of a kind, one of ${HOSTS[host].references.join(", ")}`));
+        sound = false;
+      }
+    } else if (typeof s["list"] !== "string" || !NAME.test(s["list"])) {
+      out.push(err2("pick-list", atKey(at, "list"), "a list source names a field of the extension's project node"));
+      sound = false;
+    }
+  });
+  return sound;
+}
+function pickListProblems(kinds, hostPath, out) {
+  const project = isObject(kinds["project"]) && Array.isArray(kinds["project"]["fields"]) ? kinds["project"]["fields"] : [];
+  const lists = new Set(project.filter((f) => isObject(f) && isTextList(f)).map((f) => f.name));
+  const walk = (decl, path) => {
+    if (!isObject(decl)) return;
+    const d = decl;
+    if (d.type === "pick" && Array.isArray(d.from)) {
+      d.from.forEach((s, i) => {
+        if (isObject(s) && typeof s.list === "string" && !lists.has(s.list)) {
+          const name = s.list;
+          out.push(err2(
+            "pick-list",
+            atKey(atIndex(atKey(path, "from"), i), "list"),
+            `"${name}" is not a list of text on the extension's project node; declare it there, as { "name": "${name}", "type": "list", "of": { "type": "text" } }`
+          ));
+        }
+      });
+    }
+    if (Array.isArray(d.fields)) d.fields.forEach((f, i) => walk(f, atIndex(atKey(path, "fields"), i)));
+    if (d.of !== void 0) walk(d.of, atKey(path, "of"));
+  };
+  for (const [kind, target] of Object.entries(kinds)) {
+    if (!isObject(target) || !Array.isArray(target["fields"])) continue;
+    target["fields"].forEach((f, i) => walk(f, atIndex(atKey(atKey(hostPath, kind), "fields"), i)));
+  }
+}
 function unknownKeys(obj, known, path, out) {
   for (const k of Object.keys(obj)) {
     if (!known.has(k)) {
@@ -501,6 +650,9 @@ function typeProblems(host, decl, path, named, out, claim = false) {
         sound = false;
       }
       break;
+    case "pick":
+      if (!pickSourcesSound(host, decl.from, at("from"), out)) sound = false;
+      break;
     case "record":
       if (!Array.isArray(decl.fields) || decl.fields.length === 0) {
         out.push(err2("record-empty", at("fields"), "a record declares its fields"));
@@ -993,6 +1145,7 @@ exports.defaultOf = defaultOf;
 exports.effectiveClaim = effectiveClaim;
 exports.entryProblems = entryProblems;
 exports.extensionDataStrategy = extensionDataStrategy;
+exports.isTextList = isTextList;
 exports.keyedBy = keyedBy;
 exports.manifestProblems = manifestProblems;
 exports.mapOf = mapOf;
@@ -1003,6 +1156,9 @@ exports.mergeTree = mergeTree;
 exports.objectOf = objectOf;
 exports.orphanedEntries = orphanedEntries;
 exports.parseManifest = parseManifest;
+exports.pickChoices = pickChoices;
+exports.pickClashes = pickClashes;
+exports.pickLists = pickLists;
 exports.renameStages = renameStages;
 exports.resolvedClaims = resolvedClaims;
 exports.settingValues = settingValues;