@zodal/dials-ui 0.1.0

package/dist/index.cjs

@@ -0,0 +1,597 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  PRIORITY: () => import_ui.PRIORITY,
+  alwaysMatch: () => alwaysMatch,
+  and: () => import_ui.and,
+  applyLayerPatch: () => applyLayerPatch,
+  applyScopedFilters: () => applyScopedFilters,
+  createLocalStorageProfileStorage: () => createLocalStorageProfileStorage,
+  createMemoryProfileStorage: () => createMemoryProfileStorage,
+  createProfileStore: () => createProfileStore,
+  createRendererRegistry: () => import_ui.createRendererRegistry,
+  createSettingsRendererRegistry: () => createSettingsRendererRegistry,
+  createSettingsStore: () => createSettingsStore,
+  createSubstringSearchProvider: () => createSubstringSearchProvider,
+  describeSettings: () => describeSettings,
+  dirtyKeys: () => dirtyKeys,
+  editWidgetIs: () => import_ui.editWidgetIs,
+  fieldNameMatches: () => import_ui.fieldNameMatches,
+  hasRefinement: () => import_ui.hasRefinement,
+  isBoolean: () => isBoolean,
+  isDirty: () => isDirty,
+  isEnum: () => isEnum,
+  isNumber: () => isNumber,
+  isString: () => isString,
+  isStructuredValue: () => isStructuredValue,
+  metaMatches: () => import_ui.metaMatches,
+  or: () => import_ui.or,
+  parseScopedQuery: () => parseScopedQuery,
+  recordLayerChange: () => recordLayerChange,
+  resetToDefault: () => resetToDefault,
+  searchSettings: () => searchSettings,
+  secretRoleIs: () => secretRoleIs,
+  toFieldStates: () => toFieldStates,
+  toGroups: () => toGroups,
+  toIndexableSettings: () => toIndexableSettings,
+  toSettingsForm: () => toSettingsForm,
+  unsetKey: () => unsetKey,
+  widgetKindFor: () => widgetKindFor,
+  zodTypeIs: () => import_ui.zodTypeIs
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/widgets.ts
+var KNOWN_WIDGETS = /* @__PURE__ */ new Set([
+  "switch",
+  "select",
+  "radio",
+  "slider",
+  "number",
+  "text",
+  "textarea",
+  "secret",
+  "color",
+  "date",
+  "path",
+  "object",
+  "array",
+  "rawJson"
+]);
+function widgetKindFor(input) {
+  if (typeof input.metaWidget === "string" && KNOWN_WIDGETS.has(input.metaWidget)) {
+    return input.metaWidget;
+  }
+  if (input.sensitivity === "secret") return "secret";
+  switch (input.zodType) {
+    case "boolean":
+      return "switch";
+    case "enum":
+      return input.enumValues && input.enumValues.length > 0 && input.enumValues.length <= 4 ? "radio" : "select";
+    case "number":
+      return input.bounds && input.bounds.min !== void 0 && input.bounds.max !== void 0 ? "slider" : "number";
+    case "string":
+      return "text";
+    case "object":
+      return "object";
+    case "array":
+      return "array";
+    default:
+      return "rawJson";
+  }
+}
+
+// src/registry.ts
+var import_ui = require("@zodal/ui");
+function secretRoleIs() {
+  return (_field, ctx) => ctx.sensitivity === "secret" ? import_ui.PRIORITY.OVERRIDE : -1;
+}
+function isStructuredValue() {
+  return (field, ctx) => ctx.structured === true || field.zodType === "object" || field.zodType === "array" ? import_ui.PRIORITY.LIBRARY : -1;
+}
+function isBoolean() {
+  return (0, import_ui.zodTypeIs)("boolean");
+}
+function isEnum() {
+  return (0, import_ui.zodTypeIs)("enum");
+}
+function isNumber() {
+  return (0, import_ui.zodTypeIs)("number");
+}
+function isString() {
+  return (0, import_ui.zodTypeIs)("string");
+}
+function alwaysMatch(priority = import_ui.PRIORITY.FALLBACK) {
+  return () => priority;
+}
+function createSettingsRendererRegistry() {
+  return (0, import_ui.createRendererRegistry)();
+}
+
+// src/introspect.ts
+var import_dials_core = require("@zodal/dials-core");
+var import_core = require("@zodal/core");
+function safe(fn) {
+  try {
+    return fn();
+  } catch {
+    return void 0;
+  }
+}
+function uniqueStrings(values) {
+  return [...new Set(values)];
+}
+function describeSettings(dials, options = {}) {
+  const shape = (0, import_dials_core.getObjectShape)(dials.schema);
+  return dials.keys.map((key) => {
+    const field = shape[key];
+    const meta = field ? (0, import_dials_core.readMeta)(field) : {};
+    const zodType = field ? (0, import_dials_core.baseType)(field) : "unknown";
+    const sensitivity = dials.sensitivityFor(key);
+    const enumValues = field ? safe(() => (0, import_core.getEnumValues)(field)) : void 0;
+    const rawBounds = field ? safe(() => (0, import_core.getNumericBounds)(field)) : void 0;
+    const min = rawBounds != null && Number.isFinite(rawBounds.min) ? rawBounds.min : void 0;
+    const max = rawBounds != null && Number.isFinite(rawBounds.max) ? rawBounds.max : void 0;
+    const bounds = min !== void 0 || max !== void 0 ? { ...min !== void 0 ? { min } : {}, ...max !== void 0 ? { max } : {} } : void 0;
+    const metaFacets = Array.isArray(meta.facets) ? meta.facets.map((f) => String(f)) : [];
+    const facets = uniqueStrings([...metaFacets, ...options.facets?.[key] ?? []]);
+    const advanced = facets.includes("advanced") || meta.advanced === true;
+    const required = field ? !field.safeParse(void 0).success && dials.defaults[key] === void 0 : false;
+    return {
+      key,
+      label: typeof meta.title === "string" ? meta.title : (0, import_core.humanizeFieldName)(key),
+      description: typeof meta.description === "string" ? meta.description : void 0,
+      widget: widgetKindFor({ zodType, sensitivity, bounds, enumValues, metaWidget: meta.editWidget }),
+      zodType,
+      required,
+      readOnly: meta.readOnly === true || meta.editable === false,
+      hidden: meta.hidden === true,
+      sensitivity,
+      mergeStrategy: dials.mergeStrategyFor(key),
+      // Never put a secret's plaintext default into the headless config — a renderer that prefills
+      // from `defaultValue` would expose it. Secrets carry no default here (the secret backend owns it).
+      defaultValue: sensitivity === "secret" ? void 0 : dials.defaults[key],
+      enumValues: enumValues && enumValues.length > 0 ? enumValues : void 0,
+      bounds,
+      facets,
+      advanced,
+      order: typeof meta.order === "number" ? meta.order : void 0,
+      isStructured: zodType === "object" || zodType === "array"
+    };
+  });
+}
+
+// src/facets.ts
+function humanize(id) {
+  return id.replace(/^@/, "").replace(/[._-]+/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function computedGroups(fields, result) {
+  const out = [];
+  const add = (id, title, keys, order) => {
+    if (keys.length > 0) out.push({ id, title, order, settingKeys: keys, computed: true });
+  };
+  const fieldKeys = new Set(fields.map((f) => f.key));
+  add("@secret", "Secrets", fields.filter((f) => f.sensitivity === "secret").map((f) => f.key), 2e3);
+  add("@advanced", "Advanced", fields.filter((f) => f.advanced).map((f) => f.key), 2001);
+  if (result) {
+    const modified = Object.keys(result.provenance).filter((k) => fieldKeys.has(k) && result.provenance[k].winningScope !== "default");
+    const managed = Object.keys(result.provenance).filter((k) => fieldKeys.has(k) && result.provenance[k].managed);
+    add("@modified", "Modified", modified, 2002);
+    add("@managed", "Managed by policy", managed, 2003);
+  }
+  return out;
+}
+function toGroups(fields, result, options = {}) {
+  const declared = new Map((options.facetDefs ?? []).map((f) => [f.id, f]));
+  const forward = /* @__PURE__ */ new Map();
+  for (const field of fields) {
+    for (const facet of field.facets) {
+      const list = forward.get(facet);
+      if (list) list.push(field.key);
+      else forward.set(facet, [field.key]);
+    }
+  }
+  const groups = [];
+  for (const [facet, keys] of forward) {
+    const def = declared.get(facet);
+    groups.push({ id: facet, title: def?.title ?? humanize(facet), order: def?.order ?? 100, settingKeys: keys, computed: false });
+  }
+  const seenIds = new Set(groups.map((g) => g.id));
+  const ungrouped = fields.filter((f) => f.facets.length === 0).map((f) => f.key);
+  if (ungrouped.length > 0 && !seenIds.has("_ungrouped")) {
+    groups.push({ id: "_ungrouped", title: options.ungroupedTitle ?? "Other", order: 1e3, settingKeys: ungrouped, computed: false });
+    seenIds.add("_ungrouped");
+  }
+  if (options.computedGroups !== false) {
+    for (const group of computedGroups(fields, result)) {
+      if (!seenIds.has(group.id)) {
+        groups.push(group);
+        seenIds.add(group.id);
+      }
+    }
+  }
+  return groups.sort((a, b) => a.order - b.order || a.title.localeCompare(b.title));
+}
+
+// src/search.ts
+function toIndexableSettings(fields) {
+  return fields.map((f) => ({
+    key: f.key,
+    title: f.label,
+    description: f.description ?? "",
+    enumLabels: f.enumValues ?? [],
+    facets: f.facets,
+    keywords: [f.key, ...f.key.split(/[._\-/]/).filter(Boolean)]
+  }));
+}
+function createSubstringSearchProvider(settings, options = {}) {
+  const fields = options.fields ?? ["title", "description", "enumLabels", "facets", "keywords"];
+  const haystacks = settings.map((s) => ({
+    key: s.key,
+    parts: {
+      title: s.title.toLowerCase(),
+      description: s.description.toLowerCase(),
+      enumLabels: s.enumLabels.join(" ").toLowerCase(),
+      facets: s.facets.join(" ").toLowerCase(),
+      keywords: s.keywords.join(" ").toLowerCase()
+    }
+  }));
+  return {
+    search(query) {
+      const q = query.trim().toLowerCase();
+      if (!q) return settings.map((s) => s.key);
+      const scored = [];
+      for (const h of haystacks) {
+        let score = 0;
+        for (const f of fields) {
+          if (h.parts[f].includes(q)) score += f === "title" || f === "keywords" ? 3 : 1;
+        }
+        if (score > 0) scored.push({ key: h.key, score });
+      }
+      scored.sort((a, b) => b.score - a.score);
+      return scored.map((s) => s.key);
+    }
+  };
+}
+function parseScopedQuery(query) {
+  const tokens = query.split(/\s+/).filter(Boolean);
+  const filters = [];
+  const text = [];
+  for (const tok of tokens) {
+    const m = /^@([a-z]+)(?::(.+))?$/i.exec(tok);
+    if (!m) {
+      text.push(tok);
+      continue;
+    }
+    const name = m[1].toLowerCase();
+    const value = m[2];
+    if (name === "modified") filters.push({ type: "modified" });
+    else if (name === "managed") filters.push({ type: "managed" });
+    else if (name === "secret") filters.push({ type: "secret" });
+    else if (name === "advanced") filters.push({ type: "advanced" });
+    else if (name === "facet" && value) filters.push({ type: "facet", value });
+    else if (name === "scope" && value) filters.push({ type: "scope", value });
+    else text.push(tok);
+  }
+  return { filters, text: text.join(" ") };
+}
+function applyScopedFilters(keys, filters, context) {
+  if (filters.length === 0) return keys;
+  const byKey = new Map(context.fields.map((f) => [f.key, f]));
+  const prov = context.result?.provenance ?? {};
+  return keys.filter(
+    (key) => filters.every((filter) => {
+      const f = byKey.get(key);
+      switch (filter.type) {
+        case "secret":
+          return f?.sensitivity === "secret";
+        case "advanced":
+          return f?.advanced === true;
+        case "facet":
+          return f?.facets.includes(filter.value) ?? false;
+        case "modified":
+          return prov[key] ? prov[key].winningScope !== "default" : false;
+        case "managed":
+          return prov[key]?.managed === true;
+        case "scope":
+          return prov[key]?.winningScope === filter.value;
+        default:
+          return true;
+      }
+    })
+  );
+}
+function searchSettings(query, provider, context) {
+  const { filters, text } = parseScopedQuery(query);
+  const allKeys = context.fields.map((f) => f.key);
+  const filtered = new Set(applyScopedFilters(allKeys, filters, context));
+  const ranked = text ? provider.search(text) : allKeys;
+  return ranked.filter((k) => filtered.has(k));
+}
+
+// src/lifecycle.ts
+var import_dials_core2 = require("@zodal/dials-core");
+function normalize(value) {
+  if (value === import_dials_core2.UNSET) return "\0unset";
+  if (value === void 0) return "\0undefined";
+  return JSON.stringify(value);
+}
+function dirtyKeys(current, baseline) {
+  const keys = /* @__PURE__ */ new Set([...Object.keys(current), ...Object.keys(baseline)]);
+  const out = [];
+  for (const key of keys) {
+    const inCurrent = Object.prototype.hasOwnProperty.call(current, key);
+    const inBaseline = Object.prototype.hasOwnProperty.call(baseline, key);
+    if (inCurrent !== inBaseline || normalize(current[key]) !== normalize(baseline[key])) out.push(key);
+  }
+  return out;
+}
+function isDirty(current, baseline) {
+  return dirtyKeys(current, baseline).length > 0;
+}
+function resetToDefault(layer, key) {
+  const out = { ...layer };
+  delete out[key];
+  return out;
+}
+function unsetKey(layer, key) {
+  return { ...layer, [key]: import_dials_core2.UNSET };
+}
+function recordLayerChange(before, after) {
+  const b = (0, import_dials_core2.serializeLayer)(before);
+  const a = (0, import_dials_core2.serializeLayer)(after);
+  const forward = (0, import_dials_core2.diffJsonPatch)(b, a);
+  return { forward, inverse: (0, import_dials_core2.invertJsonPatch)(forward, b) };
+}
+function applyLayerPatch(layer, ops) {
+  const serialized = (0, import_dials_core2.applyJsonPatch)((0, import_dials_core2.serializeLayer)(layer), ops);
+  return (0, import_dials_core2.deserializeLayer)(serialized);
+}
+
+// src/form.ts
+var import_dials_core3 = require("@zodal/dials-core");
+function toSettingsForm(dials, options = {}) {
+  const all = describeSettings(dials, { facets: options.facets });
+  const visible = options.includeHidden ? all : all.filter((f) => !f.hidden);
+  const fields = [...visible].sort((a, b) => (a.order ?? 1e3) - (b.order ?? 1e3) || a.label.localeCompare(b.label));
+  const groups = toGroups(fields, options.result, {
+    facetDefs: options.facetDefs,
+    computedGroups: options.computedGroups,
+    ungroupedTitle: options.ungroupedTitle
+  });
+  return { fields, groups };
+}
+function toFieldStates(fields, result, dirty = []) {
+  const dirtySet = new Set(dirty);
+  const states = {};
+  for (const field of fields) {
+    const prov = result.provenance[field.key];
+    const raw = result.effective[field.key];
+    const value = field.sensitivity === "secret" && !(0, import_dials_core3.isSecretRef)(raw) ? (0, import_dials_core3.makeSecretRef)(field.key, raw !== void 0 && raw !== null && raw !== "") : raw;
+    states[field.key] = {
+      value,
+      source: prov?.winningScope,
+      managed: prov?.managed ?? false,
+      shadowed: (prov?.shadowed.length ?? 0) > 0,
+      dirty: dirtySet.has(field.key)
+    };
+  }
+  return states;
+}
+
+// src/store.ts
+var import_dials_core4 = require("@zodal/dials-core");
+function createSettingsStore(dials, options = {}) {
+  const scopeId = options.scope ?? "user";
+  const maskSecrets = options.maskSecrets !== false;
+  const listeners = /* @__PURE__ */ new Set();
+  let scopes = [...options.scopes ?? []];
+  let layer = { ...options.layer ?? {} };
+  let baseline = { ...layer };
+  let state;
+  const recompute = () => {
+    const raw = dials.resolve([...scopes, { scope: scopeId, layer }]);
+    const validation = dials.validate(raw.effective);
+    const shown = maskSecrets ? (0, import_dials_core4.maskEffectiveResult)(raw, dials.sensitivityFor) : raw;
+    state = {
+      effective: shown.effective,
+      provenance: shown.provenance,
+      conflicts: shown.conflicts,
+      layer: { ...layer },
+      scopes: [...scopes],
+      dirty: dirtyKeys(layer, baseline),
+      validation
+    };
+    for (const listener of [...listeners]) {
+      try {
+        listener();
+      } catch (error) {
+        options.onListenerError?.(error);
+      }
+    }
+  };
+  recompute();
+  const mutate = (next) => {
+    layer = next;
+    recompute();
+  };
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    set: (key, value) => {
+      if (Object.prototype.hasOwnProperty.call(layer, key) && Object.is(layer[key], value)) return;
+      mutate({ ...layer, [key]: value });
+    },
+    unset: (key) => mutate({ ...layer, [key]: import_dials_core4.UNSET }),
+    reset: (key) => {
+      const next = { ...layer };
+      delete next[key];
+      mutate(next);
+    },
+    setLayer: (next) => mutate({ ...next }),
+    setScopes: (next) => {
+      scopes = [...next];
+      recompute();
+    },
+    markSaved: () => {
+      baseline = { ...layer };
+      recompute();
+    },
+    get: (key) => state.effective[key],
+    explain: (key) => state.provenance[key]
+  };
+}
+
+// src/profiles.ts
+var import_dials_core5 = require("@zodal/dials-core");
+function createMemoryProfileStorage(initial = []) {
+  let profiles = initial.map((p) => ({ ...p }));
+  return {
+    read: () => Promise.resolve(profiles.map((p) => ({ ...p }))),
+    write: (next) => {
+      profiles = next.map((p) => ({ ...p }));
+      return Promise.resolve();
+    }
+  };
+}
+function createLocalStorageProfileStorage(storageKey = "zodal-dials.profiles") {
+  const ls = globalThis.localStorage;
+  if (!ls) throw new Error("createLocalStorageProfileStorage: localStorage is not available");
+  return {
+    read: () => {
+      const raw = ls.getItem(storageKey);
+      if (!raw) return Promise.resolve([]);
+      try {
+        const parsed = JSON.parse(raw);
+        return Promise.resolve(Array.isArray(parsed) ? parsed : []);
+      } catch {
+        return Promise.resolve([]);
+      }
+    },
+    write: (profiles) => {
+      ls.setItem(storageKey, JSON.stringify(profiles));
+      return Promise.resolve();
+    }
+  };
+}
+function createProfileStore(storage, options = {}) {
+  const findIndex = (profiles, name) => profiles.findIndex((p) => p.name === name);
+  let queue = Promise.resolve();
+  const enqueue = (run) => {
+    const result = queue.then(run, run);
+    queue = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  };
+  return {
+    async list() {
+      const profiles = await storage.read();
+      return profiles.map(({ name, meta }) => ({ name, ...meta ? { meta } : {} }));
+    },
+    save(name, layer, meta) {
+      const trimmed = name.trim();
+      if (!trimmed) return Promise.reject(new Error("profile name cannot be empty"));
+      return enqueue(async () => {
+        const profiles = await storage.read();
+        let serialized = (0, import_dials_core5.serializeLayer)(layer);
+        if (options.sensitivityFor) serialized = (0, import_dials_core5.redactSecretsFromLayer)(serialized, options.sensitivityFor);
+        const entry = { name: trimmed, layer: serialized, ...meta ? { meta } : {} };
+        const index = findIndex(profiles, trimmed);
+        if (index >= 0) profiles[index] = entry;
+        else profiles.push(entry);
+        await storage.write(profiles);
+      });
+    },
+    async load(name) {
+      const profiles = await storage.read();
+      const found = profiles[findIndex(profiles, name)];
+      return found ? (0, import_dials_core5.deserializeLayer)(found.layer) : void 0;
+    },
+    remove(name) {
+      return enqueue(async () => {
+        const profiles = await storage.read();
+        await storage.write(profiles.filter((p) => p.name !== name));
+      });
+    },
+    rename(from, to) {
+      if (from === to) return Promise.resolve();
+      return enqueue(async () => {
+        const profiles = await storage.read();
+        if (findIndex(profiles, to) >= 0) throw new Error(`profile "${to}" already exists`);
+        const index = findIndex(profiles, from);
+        if (index < 0) return;
+        profiles[index] = { ...profiles[index], name: to };
+        await storage.write(profiles);
+      });
+    },
+    async has(name) {
+      const profiles = await storage.read();
+      return findIndex(profiles, name) >= 0;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PRIORITY,
+  alwaysMatch,
+  and,
+  applyLayerPatch,
+  applyScopedFilters,
+  createLocalStorageProfileStorage,
+  createMemoryProfileStorage,
+  createProfileStore,
+  createRendererRegistry,
+  createSettingsRendererRegistry,
+  createSettingsStore,
+  createSubstringSearchProvider,
+  describeSettings,
+  dirtyKeys,
+  editWidgetIs,
+  fieldNameMatches,
+  hasRefinement,
+  isBoolean,
+  isDirty,
+  isEnum,
+  isNumber,
+  isString,
+  isStructuredValue,
+  metaMatches,
+  or,
+  parseScopedQuery,
+  recordLayerChange,
+  resetToDefault,
+  searchSettings,
+  secretRoleIs,
+  toFieldStates,
+  toGroups,
+  toIndexableSettings,
+  toSettingsForm,
+  unsetKey,
+  widgetKindFor,
+  zodTypeIs
+});
+//# sourceMappingURL=index.cjs.map