@grafana/plugin-ui 0.13.1 → 0.14.1-dsconfig.032cfc4

package/dist/esm/schema/registry/yesoreyeram-infinity-datasource.schema.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"yesoreyeram-infinity-datasource.schema.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/schema/registry/zipkin.schema.json.js

@@ -0,0 +1,40 @@
+var $schema = "../schema.json";
+var schemaVersion = "v1";
+var pluginType = "zipkin";
+var pluginName = "Zipkin";
+var docURL = "https://grafana.com/docs/grafana/latest/datasources/zipkin/";
+var fields = [
+	{
+		id: "jsonData.nodeGraph.enabled",
+		key: "enabled",
+		label: "Enable node graph",
+		description: "Shows the node graph visualization above the trace view.",
+		valueType: "boolean",
+		target: "jsonData",
+		section: "nodeGraph",
+		ui: {
+			component: "switch"
+		}
+	}
+];
+var groups = [
+	{
+		id: "node-graph",
+		title: "Node graph",
+		fieldRefs: [
+			"jsonData.nodeGraph.enabled"
+		]
+	}
+];
+var zipkinSchema = {
+	$schema: $schema,
+	schemaVersion: schemaVersion,
+	pluginType: pluginType,
+	pluginName: pluginName,
+	docURL: docURL,
+	fields: fields,
+	groups: groups
+};
+
+export { $schema, zipkinSchema as default, docURL, fields, groups, pluginName, pluginType, schemaVersion };
+//# sourceMappingURL=zipkin.schema.json.js.map

package/dist/esm/schema/registry/zipkin.schema.json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zipkin.schema.json.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/schema/utils/dsconfig.js

@@ -0,0 +1,97 @@
+const ROOT_CONFIG_FIELDS = [
+  "name",
+  "type",
+  "id",
+  "uid",
+  "access",
+  "url",
+  "basicAuth",
+  "basicAuthUser",
+  "user",
+  "isDefault",
+  "database",
+  "withCredentials"
+];
+const buildCreateDatasourcePayload = (input) => {
+  const body = { name: input.name, type: input.type, access: "proxy" };
+  if (input.jsonData !== void 0) {
+    body.jsonData = { ...input.jsonData };
+  }
+  normalizeDatasourceConfig(body, input, { inferAuthMethod: true });
+  return body;
+};
+const buildCloneDatasourcePayload = (source, name) => {
+  var _a;
+  return { ...source, name, access: (_a = source.access) != null ? _a : "proxy", isDefault: false };
+};
+const buildUpdateDatasourcePayload = (existing, input) => {
+  var _a;
+  const body = {
+    name: existing.name,
+    type: existing.type,
+    access: existing.access,
+    url: existing.url,
+    database: existing.database,
+    basicAuth: existing.basicAuth,
+    basicAuthUser: existing.basicAuthUser,
+    isDefault: existing.isDefault,
+    user: existing.user,
+    withCredentials: existing.withCredentials,
+    jsonData: existing.jsonData
+  };
+  let hasChanges = false;
+  const UPDATE_COMPARABLE_FIELDS = ["name", "url", "database", "isDefault", "basicAuth"];
+  for (const key of UPDATE_COMPARABLE_FIELDS) {
+    if (input[key] !== void 0 && input[key] !== existing[key]) {
+      body[key] = input[key];
+      hasChanges = true;
+    }
+  }
+  if (input.jsonData !== void 0) {
+    body.jsonData = { ...(_a = existing.jsonData) != null ? _a : {}, ...input.jsonData };
+    hasChanges = true;
+    hasChanges = normalizeDatasourceConfig(body, input) || hasChanges;
+  }
+  return { body, hasChanges };
+};
+const normalizeDatasourceConfig = (body, input, options = {}) => {
+  const changed = hoistRootConfigFields(body, input);
+  if (options.inferAuthMethod) {
+    applyInferredAuthMethod(body, input);
+  }
+  return changed;
+};
+const hoistRootConfigFields = (body, input) => {
+  var _a;
+  const jsonData = (_a = body.jsonData) != null ? _a : {};
+  let changed = false;
+  for (const key of ROOT_CONFIG_FIELDS) {
+    if (jsonData[key] === void 0) {
+      continue;
+    }
+    if (input[key] === void 0) {
+      body[key] = jsonData[key];
+      changed = true;
+    }
+    delete jsonData[key];
+  }
+  body.jsonData = jsonData;
+  return changed;
+};
+const applyInferredAuthMethod = (body, input) => {
+  var _a;
+  const jsonData = (_a = body.jsonData) != null ? _a : {};
+  if (jsonData.authMethod !== void 0) {
+    body.jsonData = jsonData;
+    return;
+  }
+  if (jsonData.oauthPassThru === true) {
+    jsonData.authMethod = "forward_oauth";
+  } else if (body.basicAuth === true || input.basicAuth === true) {
+    jsonData.authMethod = "basic";
+  }
+  body.jsonData = jsonData;
+};
+
+export { ROOT_CONFIG_FIELDS, buildCloneDatasourcePayload, buildCreateDatasourcePayload, buildUpdateDatasourcePayload };
+//# sourceMappingURL=dsconfig.js.map

package/dist/esm/schema/utils/dsconfig.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dsconfig.js","sources":["../../../../src/schema/utils/dsconfig.ts"],"sourcesContent":["export const ROOT_CONFIG_FIELDS = [\n  'name',\n  'type',\n  'id',\n  'uid',\n  'access',\n  'url',\n  'basicAuth',\n  'basicAuthUser',\n  'user',\n  'isDefault',\n  'database',\n  'withCredentials',\n] as const;\n\ntype DatasourceConfig = Record<any, any>;\n\nexport const buildCreateDatasourcePayload = (input: DatasourceConfig): DatasourceConfig => {\n  const body: DatasourceConfig = { name: input.name, type: input.type, access: 'proxy' };\n  if (input.jsonData !== undefined) {\n    body.jsonData = { ...(input.jsonData as DatasourceConfig) };\n  }\n  normalizeDatasourceConfig(body, input, { inferAuthMethod: true });\n  return body;\n};\n\nexport const buildCloneDatasourcePayload = (source: DatasourceConfig, name: string): DatasourceConfig => {\n  return { ...source, name, access: source.access ?? 'proxy', isDefault: false };\n};\n\nexport const buildUpdateDatasourcePayload = (\n  existing: DatasourceConfig,\n  input: DatasourceConfig\n): { body: DatasourceConfig; hasChanges: boolean } => {\n  const body: DatasourceConfig = {\n    name: existing.name,\n    type: existing.type,\n    access: existing.access,\n    url: existing.url,\n    database: existing.database,\n    basicAuth: existing.basicAuth,\n    basicAuthUser: existing.basicAuthUser,\n    isDefault: existing.isDefault,\n    user: existing.user,\n    withCredentials: existing.withCredentials,\n    jsonData: existing.jsonData,\n  };\n  let hasChanges = false;\n  const UPDATE_COMPARABLE_FIELDS = ['name', 'url', 'database', 'isDefault', 'basicAuth'] as const;\n  for (const key of UPDATE_COMPARABLE_FIELDS) {\n    if (input[key] !== undefined && input[key] !== existing[key]) {\n      body[key] = input[key];\n      hasChanges = true;\n    }\n  }\n\n  if (input.jsonData !== undefined) {\n    body.jsonData = { ...((existing.jsonData ?? {}) as DatasourceConfig), ...(input.jsonData as DatasourceConfig) };\n    hasChanges = true;\n    hasChanges = normalizeDatasourceConfig(body, input) || hasChanges;\n  }\n\n  return { body, hasChanges };\n};\n\nconst normalizeDatasourceConfig = (\n  body: DatasourceConfig,\n  input: DatasourceConfig,\n  options: { inferAuthMethod?: boolean } = {}\n): boolean => {\n  const changed = hoistRootConfigFields(body, input);\n  if (options.inferAuthMethod) {\n    applyInferredAuthMethod(body, input);\n  }\n  return changed;\n};\n\nconst hoistRootConfigFields = (body: DatasourceConfig, input: DatasourceConfig): boolean => {\n  const jsonData = (body.jsonData as DatasourceConfig | undefined) ?? {};\n  let changed = false;\n\n  for (const key of ROOT_CONFIG_FIELDS) {\n    if (jsonData[key] === undefined) {\n      continue;\n    }\n\n    if (input[key] === undefined) {\n      body[key] = jsonData[key];\n      changed = true;\n    }\n\n    delete jsonData[key];\n  }\n\n  body.jsonData = jsonData;\n  return changed;\n};\n\nconst applyInferredAuthMethod = (body: DatasourceConfig, input: DatasourceConfig): void => {\n  const jsonData = (body.jsonData as DatasourceConfig | undefined) ?? {};\n\n  if (jsonData.authMethod !== undefined) {\n    body.jsonData = jsonData;\n    return;\n  }\n\n  if (jsonData.oauthPassThru === true) {\n    jsonData.authMethod = 'forward_oauth';\n  } else if (body.basicAuth === true || input.basicAuth === true) {\n    jsonData.authMethod = 'basic';\n  }\n\n  body.jsonData = jsonData;\n};\n"],"names":[],"mappings":"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"}

package/dist/esm/schema/utils/llm.js

@@ -0,0 +1,54 @@
+function generateLLMHint(schema) {
+  var _a, _b, _c, _d;
+  const hints = [];
+  for (const field of schema.fields) {
+    if (((_a = field.ui) == null ? void 0 : _a.component) !== "select" || field.target !== "jsonData" || field.kind === "virtual") {
+      continue;
+    }
+    const options = (_c = (_b = field.ui) == null ? void 0 : _b.options) != null ? _c : [];
+    const values = options.map((opt) => {
+      const isDefault = field.defaultValue != null && String(opt.value) === String(field.defaultValue);
+      return isDefault ? `"${opt.value}" (default)` : `"${opt.value}"`;
+    }).join(", ");
+    if (values) {
+      hints.push(`- ${(_d = field.label) != null ? _d : field.key}: jsonData.${field.key} \u2014 values: ${values}`);
+    }
+  }
+  return hints.join("\n");
+}
+function generateTroubleshootingFields(schema) {
+  var _a, _b, _c;
+  const result = [];
+  for (const field of schema.fields) {
+    if (field.kind === "virtual" || field.isItemField) {
+      continue;
+    }
+    const entry = {
+      label: (_a = field.label) != null ? _a : field.key,
+      key: field.target === "root" ? field.key : `${field.target}.${field.key}`,
+      target: (_b = field.target) != null ? _b : "jsonData",
+      type: field.valueType,
+      required: !!field.required
+    };
+    if (field.description) {
+      entry.description = field.description;
+    }
+    if (field.defaultValue != null) {
+      entry.defaultValue = field.defaultValue;
+    }
+    if (((_c = field.ui) == null ? void 0 : _c.options) && field.ui.options.length > 0) {
+      entry.options = field.ui.options.map((o) => String(o.value));
+    }
+    if (field.section) {
+      entry.section = field.section;
+    }
+    if (field.dependsOn) {
+      entry.dependsOn = field.dependsOn;
+    }
+    result.push(entry);
+  }
+  return result;
+}
+
+export { generateLLMHint, generateTroubleshootingFields };
+//# sourceMappingURL=llm.js.map

package/dist/esm/schema/utils/llm.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"llm.js","sources":["../../../../src/schema/utils/llm.ts"],"sourcesContent":["import type { DatasourceConfigSchema } from '../schema';\n\n/**\n * Generate LLM hints for select fields (used when creating datasources).\n */\nexport function generateLLMHint(schema: DatasourceConfigSchema): string {\n  const hints: string[] = [];\n  for (const field of schema.fields) {\n    if (field.ui?.component !== 'select' || field.target !== 'jsonData' || field.kind === 'virtual') {\n      continue;\n    }\n    const options = field.ui?.options ?? [];\n    const values = options\n      .map((opt) => {\n        const isDefault = field.defaultValue != null && String(opt.value) === String(field.defaultValue);\n        return isDefault ? `\"${opt.value}\" (default)` : `\"${opt.value}\"`;\n      })\n      .join(', ');\n    if (values) {\n      hints.push(`- ${field.label ?? field.key}: jsonData.${field.key} — values: ${values}`);\n    }\n  }\n  return hints.join('\\n');\n}\n\n/**\n * Generate comprehensive structured field data for troubleshooting context.\n * Returns an array of field descriptors the LLM can use to render rich tables.\n */\nexport function generateTroubleshootingFields(schema: DatasourceConfigSchema): Array<{\n  label: string;\n  key: string;\n  target: string;\n  type: string;\n  required: boolean;\n  description?: string;\n  defaultValue?: unknown;\n  options?: string[];\n  section?: string;\n  dependsOn?: string;\n}> {\n  const result: Array<{\n    label: string;\n    key: string;\n    target: string;\n    type: string;\n    required: boolean;\n    description?: string;\n    defaultValue?: unknown;\n    options?: string[];\n    section?: string;\n    dependsOn?: string;\n  }> = [];\n  for (const field of schema.fields) {\n    if (field.kind === 'virtual' || field.isItemField) {\n      continue;\n    }\n    const entry: (typeof result)[0] = {\n      label: field.label ?? field.key,\n      key: field.target === 'root' ? field.key : `${field.target}.${field.key}`,\n      target: field.target ?? 'jsonData',\n      type: field.valueType,\n      required: !!field.required,\n    };\n    if (field.description) {\n      entry.description = field.description;\n    }\n    if (field.defaultValue != null) {\n      entry.defaultValue = field.defaultValue;\n    }\n    if (field.ui?.options && field.ui.options.length > 0) {\n      entry.options = field.ui.options.map((o) => String(o.value));\n    }\n    if (field.section) {\n      entry.section = field.section;\n    }\n    if (field.dependsOn) {\n      entry.dependsOn = field.dependsOn;\n    }\n    result.push(entry);\n  }\n  return result;\n}\n"],"names":[],"mappings":"AAKO,SAAS,gBAAgB,MAAA,EAAwC;AALxE,EAAA,IAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA,EAAA;AAME,EAAA,MAAM,QAAkB,EAAC;AACzB,EAAA,KAAA,MAAW,KAAA,IAAS,OAAO,MAAA,EAAQ;AACjC,IAAA,IAAA,CAAA,CAAI,EAAA,GAAA,KAAA,CAAM,EAAA,KAAN,IAAA,GAAA,MAAA,GAAA,EAAA,CAAU,SAAA,MAAc,QAAA,IAAY,MAAM,MAAA,KAAW,UAAA,IAAc,KAAA,CAAM,IAAA,KAAS,SAAA,EAAW;AAC/F,MAAA;AAAA,IACF;AACA,IAAA,MAAM,WAAU,EAAA,GAAA,CAAA,EAAA,GAAA,KAAA,CAAM,EAAA,KAAN,IAAA,GAAA,MAAA,GAAA,EAAA,CAAU,OAAA,KAAV,YAAqB,EAAC;AACtC,IAAA,MAAM,MAAA,GAAS,OAAA,CACZ,GAAA,CAAI,CAAC,GAAA,KAAQ;AACZ,MAAA,MAAM,SAAA,GAAY,KAAA,CAAM,YAAA,IAAgB,IAAA,IAAQ,MAAA,CAAO,IAAI,KAAK,CAAA,KAAM,MAAA,CAAO,KAAA,CAAM,YAAY,CAAA;AAC/F,MAAA,OAAO,YAAY,CAAA,CAAA,EAAI,GAAA,CAAI,KAAK,CAAA,WAAA,CAAA,GAAgB,CAAA,CAAA,EAAI,IAAI,KAAK,CAAA,CAAA,CAAA;AAAA,IAC/D,CAAC,CAAA,CACA,IAAA,CAAK,IAAI,CAAA;AACZ,IAAA,IAAI,MAAA,EAAQ;AACV,MAAA,KAAA,CAAM,IAAA,CAAK,CAAA,EAAA,EAAA,CAAK,EAAA,GAAA,KAAA,CAAM,KAAA,KAAN,IAAA,GAAA,EAAA,GAAe,KAAA,CAAM,GAAG,CAAA,WAAA,EAAc,KAAA,CAAM,GAAG,CAAA,gBAAA,EAAc,MAAM,CAAA,CAAE,CAAA;AAAA,IACvF;AAAA,EACF;AACA,EAAA,OAAO,KAAA,CAAM,KAAK,IAAI,CAAA;AACxB;AAMO,SAAS,8BAA8B,MAAA,EAW3C;AAxCH,EAAA,IAAA,EAAA,EAAA,EAAA,EAAA,EAAA;AAyCE,EAAA,MAAM,SAWD,EAAC;AACN,EAAA,KAAA,MAAW,KAAA,IAAS,OAAO,MAAA,EAAQ;AACjC,IAAA,IAAI,KAAA,CAAM,IAAA,KAAS,SAAA,IAAa,KAAA,CAAM,WAAA,EAAa;AACjD,MAAA;AAAA,IACF;AACA,IAAA,MAAM,KAAA,GAA4B;AAAA,MAChC,KAAA,EAAA,CAAO,EAAA,GAAA,KAAA,CAAM,KAAA,KAAN,IAAA,GAAA,EAAA,GAAe,KAAA,CAAM,GAAA;AAAA,MAC5B,GAAA,EAAK,KAAA,CAAM,MAAA,KAAW,MAAA,GAAS,KAAA,CAAM,GAAA,GAAM,CAAA,EAAG,KAAA,CAAM,MAAM,CAAA,CAAA,EAAI,KAAA,CAAM,GAAG,CAAA,CAAA;AAAA,MACvE,MAAA,EAAA,CAAQ,EAAA,GAAA,KAAA,CAAM,MAAA,KAAN,IAAA,GAAA,EAAA,GAAgB,UAAA;AAAA,MACxB,MAAM,KAAA,CAAM,SAAA;AAAA,MACZ,QAAA,EAAU,CAAC,CAAC,KAAA,CAAM;AAAA,KACpB;AACA,IAAA,IAAI,MAAM,WAAA,EAAa;AACrB,MAAA,KAAA,CAAM,cAAc,KAAA,CAAM,WAAA;AAAA,IAC5B;AACA,IAAA,IAAI,KAAA,CAAM,gBAAgB,IAAA,EAAM;AAC9B,MAAA,KAAA,CAAM,eAAe,KAAA,CAAM,YAAA;AAAA,IAC7B;AACA,IAAA,IAAA,CAAA,CAAI,EAAA,GAAA,KAAA,CAAM,OAAN,IAAA,GAAA,MAAA,GAAA,EAAA,CAAU,OAAA,KAAW,MAAM,EAAA,CAAG,OAAA,CAAQ,SAAS,CAAA,EAAG;AACpD,MAAA,KAAA,CAAM,OAAA,GAAU,KAAA,CAAM,EAAA,CAAG,OAAA,CAAQ,GAAA,CAAI,CAAC,CAAA,KAAM,MAAA,CAAO,CAAA,CAAE,KAAK,CAAC,CAAA;AAAA,IAC7D;AACA,IAAA,IAAI,MAAM,OAAA,EAAS;AACjB,MAAA,KAAA,CAAM,UAAU,KAAA,CAAM,OAAA;AAAA,IACxB;AACA,IAAA,IAAI,MAAM,SAAA,EAAW;AACnB,MAAA,KAAA,CAAM,YAAY,KAAA,CAAM,SAAA;AAAA,IAC1B;AACA,IAAA,MAAA,CAAO,KAAK,KAAK,CAAA;AAAA,EACnB;AACA,EAAA,OAAO,MAAA;AACT;;;;"}

package/dist/esm/schema/utils/provisioning.js

@@ -0,0 +1,434 @@
+import yaml from 'js-yaml';
+import { resolveGroups } from '../../components/ConfigEditor/DatasourceConfigWizard/config.js';
+import { ROOT_CONFIG_FIELDS } from './dsconfig.js';
+
+function yamlIndent(depth) {
+  return "  ".repeat(depth);
+}
+function yamlString(value) {
+  if (value === null || value === void 0) {
+    return '""';
+  }
+  const s = String(value);
+  if (s === "") {
+    return '""';
+  }
+  return yaml.dump(s, { lineWidth: -1 }).trimEnd();
+}
+function yamlValue(value, depth) {
+  if (value === null || value === void 0) {
+    return '""';
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  if (typeof value === "number") {
+    return String(value);
+  }
+  if (typeof value === "string") {
+    return yamlString(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const lines = value.map((item) => {
+      if (typeof item === "object" && item !== null && !Array.isArray(item)) {
+        const entries = Object.entries(item);
+        if (entries.length === 0) {
+          return `${yamlIndent(depth)}- {}`;
+        }
+        const [firstKey, firstVal] = entries[0];
+        const firstLine = `${yamlIndent(depth)}- ${yamlString(firstKey)}: ${yamlValue(firstVal, depth + 2)}`;
+        const rest = entries.slice(1).map(([k, v]) => `${yamlIndent(depth + 1)}${yamlString(k)}: ${yamlValue(v, depth + 2)}`);
+        return [firstLine, ...rest].join("\n");
+      }
+      return `${yamlIndent(depth)}- ${yamlValue(item, depth + 1)}`;
+    });
+    return "\n" + lines.join("\n");
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return "{}";
+    }
+    const lines = entries.map(([k, v]) => `${yamlIndent(depth)}${yamlString(k)}: ${yamlValue(v, depth + 1)}`);
+    return "\n" + lines.join("\n");
+  }
+  return yamlString(value);
+}
+function isCertField(field) {
+  var _a;
+  const k = field.key.toLowerCase();
+  return field.target === "secureJsonData" && (k.includes("cert") || k.includes("key") || ((_a = field.ui) == null ? void 0 : _a.component) === "textarea");
+}
+function isExcludedFromProvisioning(field) {
+  var _a, _b;
+  if (field.kind === "virtual") {
+    return true;
+  }
+  if (field.isItemField) {
+    return true;
+  }
+  if (((_a = field.tags) == null ? void 0 : _a.some((t) => t.startsWith("managed-by:"))) && field.target !== "root") {
+    return true;
+  }
+  if (((_b = field.storage) == null ? void 0 : _b.type) === "indexedPair") {
+    return true;
+  }
+  return false;
+}
+function secretPlaceholder(field) {
+  if (isCertField(field)) {
+    return "|\n      xxxxxx";
+  }
+  return "xxxxxx";
+}
+function templateValue(field) {
+  var _a;
+  if (field.defaultValue !== void 0) {
+    return field.defaultValue;
+  }
+  if (((_a = field.ui) == null ? void 0 : _a.options) && field.ui.options.length > 0) {
+    return field.ui.options[0].value;
+  }
+  switch (field.valueType) {
+    case "string":
+      return "";
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "array":
+      return [];
+    case "object":
+    case "map":
+      return {};
+    default:
+      return "";
+  }
+}
+function fieldComment(field, indent) {
+  var _a, _b, _c;
+  const parts = [];
+  const label = (_a = field.label) != null ? _a : field.key;
+  let line = label;
+  if (field.required) {
+    line += " (REQUIRED)";
+  }
+  if (field.description) {
+    line += ` \u2014 ${field.description}`;
+  }
+  parts.push(`${indent}# ${line}`);
+  const options = (_b = field.ui) == null ? void 0 : _b.options;
+  if (options && options.length > 0) {
+    const vals = options.map((o) => String(o.value)).join(", ");
+    parts.push(`${indent}# Allowed values: ${vals}`);
+  }
+  const allowedValuesRule = (_c = field.validations) == null ? void 0 : _c.find(
+    (v) => v.type === "allowedValues"
+  );
+  if (allowedValuesRule && !options) {
+    const vals = allowedValuesRule.values.map((v) => String(v)).join(", ");
+    parts.push(`${indent}# Allowed values: ${vals}`);
+  }
+  if (field.dependsOn) {
+    parts.push(`${indent}# Only when: ${field.dependsOn}`);
+  }
+  return parts.join("\n");
+}
+function toProvisioningYaml(schema, values, options) {
+  var _a, _b, _c, _d, _e, _f;
+  const isTemplate = !values;
+  const showComments = (_a = options == null ? void 0 : options.comments) != null ? _a : isTemplate;
+  const indent2 = "    ";
+  const indent3 = "      ";
+  const groups = resolveGroups(schema);
+  const rootFields = [];
+  const jsonDataFieldsByGroup = [];
+  const secureJsonDataFieldsByGroup = [];
+  const virtualFieldsWithOptions = [];
+  for (const { group, fields } of groups) {
+    const jd = [];
+    const sd = [];
+    for (const field of fields) {
+      if (field.kind === "virtual" && ((_b = field.ui) == null ? void 0 : _b.options) && field.ui.options.length > 0) {
+        virtualFieldsWithOptions.push(field);
+        continue;
+      }
+      if (isExcludedFromProvisioning(field)) {
+        continue;
+      }
+      switch (field.target) {
+        case "root":
+          rootFields.push(field);
+          break;
+        case "jsonData":
+          jd.push(field);
+          break;
+        case "secureJsonData":
+          sd.push(field);
+          break;
+      }
+    }
+    if (jd.length > 0) {
+      jsonDataFieldsByGroup.push({ group, fields: jd });
+    }
+    if (sd.length > 0) {
+      secureJsonDataFieldsByGroup.push({ group, fields: sd });
+    }
+  }
+  const allSecureJsonDataFields = secureJsonDataFieldsByGroup.flatMap((g) => g.fields);
+  const groupedFieldIds = new Set(groups.flatMap(({ group }) => group.fieldRefs));
+  for (const field of schema.fields) {
+    if (field.target === "root" && !groupedFieldIds.has(field.id) && !isExcludedFromProvisioning(field)) {
+      rootFields.push(field);
+    }
+  }
+  const lines = [];
+  lines.push("apiVersion: 1");
+  lines.push("");
+  lines.push("datasources:");
+  lines.push(`${indent2.slice(2)}- name: ${yamlString((_d = (_c = options == null ? void 0 : options.name) != null ? _c : values == null ? void 0 : values.name) != null ? _d : `my-${schema.pluginType}`)}`);
+  lines.push(`${indent2}type: ${schema.pluginType}`);
+  if (!isTemplate && (values == null ? void 0 : values.uid)) {
+    lines.push(`${indent2}uid: ${yamlString(values.uid)}`);
+  }
+  const ALREADY_EMITTED_ROOT = /* @__PURE__ */ new Set(["name", "type", "uid"]);
+  for (const field of rootFields) {
+    if (ALREADY_EMITTED_ROOT.has(field.key)) {
+      continue;
+    }
+    const val = values ? values[field.key] : templateValue(field);
+    if (val === void 0 || val === null) {
+      continue;
+    }
+    if (!isTemplate && val === false) {
+      continue;
+    }
+    if (showComments) {
+      lines.push(fieldComment(field, indent2));
+    }
+    lines.push(`${indent2}${field.key}: ${yamlValue(val, 3)}`);
+  }
+  if (showComments) {
+    for (const vf of virtualFieldsWithOptions) {
+      const label = (_e = vf.label) != null ? _e : vf.key;
+      const opts = vf.ui.options.map((o) => `${String(o.value)} (${o.label})`).join(", ");
+      lines.push(`${indent2}# ${label}: ${opts}`);
+      if (vf.description) {
+        lines.push(`${indent2}#   ${vf.description}`);
+      }
+    }
+  }
+  const emittedJsonDataKeys = /* @__PURE__ */ new Set();
+  const emittedSecureJsonDataKeys = /* @__PURE__ */ new Set();
+  const jsonDataValues = values == null ? void 0 : values.jsonData;
+  const hasJsonDataFromSchema = jsonDataFieldsByGroup.length > 0;
+  const hasJsonDataFromValues = !isTemplate && jsonDataValues && Object.keys(jsonDataValues).length > 0;
+  if (hasJsonDataFromSchema || hasJsonDataFromValues) {
+    lines.push(`${indent2}jsonData:`);
+    for (const { group, fields: groupFields } of jsonDataFieldsByGroup) {
+      if (showComments && jsonDataFieldsByGroup.length > 1) {
+        lines.push(`${indent3}# --- ${group.title} ---`);
+      }
+      for (const field of groupFields) {
+        const val = values ? getNestedValue(values, "jsonData", field) : templateValue(field);
+        if (val === void 0 || val === null) {
+          continue;
+        }
+        if (!isTemplate && field.defaultValue !== void 0 && val === field.defaultValue) {
+          continue;
+        }
+        emittedJsonDataKeys.add(field.key);
+        if (showComments) {
+          lines.push(fieldComment(field, indent3));
+        }
+        const rendered = yamlValue(val, 4);
+        if (rendered.startsWith("\n")) {
+          lines.push(`${indent3}${field.key}:${rendered}`);
+        } else {
+          lines.push(`${indent3}${field.key}: ${rendered}`);
+        }
+      }
+    }
+    if (!isTemplate && jsonDataValues) {
+      for (const [key, val] of Object.entries(jsonDataValues)) {
+        if (emittedJsonDataKeys.has(key)) {
+          continue;
+        }
+        if (val === void 0 || val === null) {
+          continue;
+        }
+        const rendered = yamlValue(val, 4);
+        if (rendered.startsWith("\n")) {
+          lines.push(`${indent3}${key}:${rendered}`);
+        } else {
+          lines.push(`${indent3}${key}: ${rendered}`);
+        }
+      }
+    }
+  }
+  const secureJsonFields = (_f = values == null ? void 0 : values.secureJsonFields) != null ? _f : {};
+  const inferredSecureKeys = !isTemplate ? inferSecureJsonDataKeys(jsonDataValues) : [];
+  const activeSecureFields = isTemplate ? allSecureJsonDataFields : allSecureJsonDataFields.filter((f) => secureJsonFields[f.key] === true);
+  if (activeSecureFields.length > 0 || inferredSecureKeys.length > 0) {
+    lines.push(`${indent2}secureJsonData:`);
+    for (const field of activeSecureFields) {
+      emittedSecureJsonDataKeys.add(field.key);
+      if (showComments) {
+        lines.push(fieldComment(field, indent3));
+      }
+      lines.push(`${indent3}${field.key}: ${secretPlaceholder(field)}`);
+    }
+    for (const key of inferredSecureKeys) {
+      if (emittedSecureJsonDataKeys.has(key)) {
+        continue;
+      }
+      lines.push(`${indent3}${key}: xxxxxx`);
+    }
+  }
+  return lines.join("\n");
+}
+function inferSecureJsonDataKeys(jsonData) {
+  if (!jsonData) {
+    return [];
+  }
+  const keys = [];
+  for (const key of Object.keys(jsonData)) {
+    const match = key.match(/^httpHeaderName(\d+)$/);
+    if (match) {
+      keys.push(`httpHeaderValue${match[1]}`);
+    }
+  }
+  return keys;
+}
+function getNestedValue(values, target, field) {
+  const nested = values[target];
+  if (nested && typeof nested === "object") {
+    return nested[field.key];
+  }
+  return void 0;
+}
+function datasourceToProvisioningYaml(ds, schema) {
+  if (schema) {
+    return toProvisioningYaml(schema, ds, { comments: false });
+  }
+  const lines = [];
+  lines.push("apiVersion: 1");
+  lines.push("");
+  lines.push("datasources:");
+  lines.push(`  - name: ${yamlString(ds.name)}`);
+  if (ds.uid) {
+    lines.push(`    uid: ${yamlString(ds.uid)}`);
+  }
+  lines.push(`    type: ${yamlString(ds.type)}`);
+  if (ds.url) {
+    lines.push(`    url: ${yamlString(ds.url)}`);
+  }
+  if (ds.database) {
+    lines.push(`    database: ${yamlString(ds.database)}`);
+  }
+  if (ds.isDefault) {
+    lines.push("    isDefault: true");
+  }
+  if (ds.basicAuth) {
+    lines.push("    basicAuth: true");
+    if (ds.basicAuthUser) {
+      lines.push(`    basicAuthUser: ${yamlString(ds.basicAuthUser)}`);
+    }
+  }
+  const jsonData = ds.jsonData;
+  if (jsonData && Object.keys(jsonData).length > 0) {
+    lines.push("    jsonData:");
+    for (const [key, val] of Object.entries(jsonData)) {
+      const rendered = yamlValue(val, 4);
+      if (rendered.startsWith("\n")) {
+        lines.push(`      ${key}:${rendered}`);
+      } else {
+        lines.push(`      ${key}: ${rendered}`);
+      }
+    }
+  }
+  lines.push("    # secureJsonData: (secrets are not exported \u2014 add manually)");
+  lines.push("    #   mySecret: xxxxxx");
+  return lines.join("\n");
+}
+function getYamlRenderOptions(ds) {
+  var _a, _b, _c;
+  return {
+    jsonDataKeys: Object.keys((_a = ds.jsonData) != null ? _a : {}).sort(),
+    secureKeys: [
+      .../* @__PURE__ */ new Set([
+        ...Object.keys((_b = ds.secureJsonData) != null ? _b : {}),
+        ...Object.keys((_c = ds.secureJsonFields) != null ? _c : {})
+      ])
+    ].sort()
+  };
+}
+const configToYaml = (ds, options = {}) => {
+  var _a, _b, _c;
+  const { jsonDataKeys, secureKeys } = {
+    ...getYamlRenderOptions(ds),
+    ...options
+  };
+  const root = {};
+  for (const key of ROOT_CONFIG_FIELDS) {
+    root[key] = (_a = ds[key]) != null ? _a : "";
+  }
+  const jsonData = (_b = ds.jsonData) != null ? _b : {};
+  if (jsonDataKeys.length > 0) {
+    const jsonDataYaml = {};
+    for (const key of jsonDataKeys) {
+      jsonDataYaml[key] = (_c = jsonData[key]) != null ? _c : "";
+    }
+    root.jsonData = jsonDataYaml;
+  }
+  if (secureKeys.length > 0) {
+    const secureJsonData = {};
+    for (const key of secureKeys) {
+      secureJsonData[key] = "********";
+    }
+    root.secureJsonData = secureJsonData;
+  }
+  return yaml.dump(root, { lineWidth: -1, sortKeys: false, noRefs: true }).trimEnd();
+};
+const formatYamlDiff = (existing, body) => {
+  var _a, _b, _c, _d, _e, _f;
+  const updated = { ...existing, ...body };
+  const existingJD = (_a = existing.jsonData) != null ? _a : {};
+  const updatedJD = (_b = updated.jsonData) != null ? _b : {};
+  const jsonDataKeys = [.../* @__PURE__ */ new Set([...Object.keys(existingJD), ...Object.keys(updatedJD)])].sort();
+  const secureKeys = [
+    .../* @__PURE__ */ new Set([
+      ...Object.keys((_c = existing.secureJsonData) != null ? _c : {}),
+      ...Object.keys((_d = existing.secureJsonFields) != null ? _d : {}),
+      ...Object.keys((_e = updated.secureJsonData) != null ? _e : {}),
+      ...Object.keys((_f = updated.secureJsonFields) != null ? _f : {})
+    ])
+  ].sort();
+  const currentYaml = configToYaml(existing, { jsonDataKeys, secureKeys });
+  const updatedYaml = configToYaml(updated, { jsonDataKeys, secureKeys });
+  const oldLines = currentYaml.split("\n");
+  const newLines = updatedYaml.split("\n");
+  const maxLen = Math.max(oldLines.length, newLines.length);
+  const diffLines = [];
+  for (let i = 0; i < maxLen; i++) {
+    const oldLine = oldLines[i];
+    const newLine = newLines[i];
+    if (oldLine === newLine) {
+      diffLines.push(` ${oldLine}`);
+      continue;
+    }
+    if (oldLine !== void 0) {
+      diffLines.push(`-${oldLine}`);
+    }
+    if (newLine !== void 0) {
+      diffLines.push(`+${newLine}`);
+    }
+  }
+  return "```diff\n" + diffLines.join("\n") + "\n```";
+};
+
+export { configToYaml, datasourceToProvisioningYaml, formatYamlDiff, toProvisioningYaml };
+//# sourceMappingURL=provisioning.js.map