@grafana/plugin-ui 0.14.1-dsconfig.f952c80 → 0.15.1

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

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

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

@@ -1,40 +0,0 @@
-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

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

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

@@ -1,97 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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":"AAAO,MAAM,kBAAA,GAAqB;AAAA,EAChC,MAAA;AAAA,EACA,MAAA;AAAA,EACA,IAAA;AAAA,EACA,KAAA;AAAA,EACA,QAAA;AAAA,EACA,KAAA;AAAA,EACA,WAAA;AAAA,EACA,eAAA;AAAA,EACA,MAAA;AAAA,EACA,WAAA;AAAA,EACA,UAAA;AAAA,EACA;AACF;AAIO,MAAM,4BAAA,GAA+B,CAAC,KAAA,KAA8C;AACzF,EAAA,MAAM,IAAA,GAAyB,EAAE,IAAA,EAAM,KAAA,CAAM,MAAM,IAAA,EAAM,KAAA,CAAM,IAAA,EAAM,MAAA,EAAQ,OAAA,EAAQ;AACrF,EAAA,IAAI,KAAA,CAAM,aAAa,MAAA,EAAW;AAChC,IAAA,IAAA,CAAK,QAAA,GAAW,EAAE,GAAI,KAAA,CAAM,QAAA,EAA8B;AAAA,EAC5D;AACA,EAAA,yBAAA,CAA0B,IAAA,EAAM,KAAA,EAAO,EAAE,eAAA,EAAiB,MAAM,CAAA;AAChE,EAAA,OAAO,IAAA;AACT;AAEO,MAAM,2BAAA,GAA8B,CAAC,MAAA,EAA0B,IAAA,KAAmC;AA1BzG,EAAA,IAAA,EAAA;AA2BE,EAAA,OAAO,EAAE,GAAG,MAAA,EAAQ,IAAA,EAAM,MAAA,EAAA,CAAQ,YAAO,MAAA,KAAP,IAAA,GAAA,EAAA,GAAiB,OAAA,EAAS,SAAA,EAAW,KAAA,EAAM;AAC/E;AAEO,MAAM,4BAAA,GAA+B,CAC1C,QAAA,EACA,KAAA,KACoD;AAjCtD,EAAA,IAAA,EAAA;AAkCE,EAAA,MAAM,IAAA,GAAyB;AAAA,IAC7B,MAAM,QAAA,CAAS,IAAA;AAAA,IACf,MAAM,QAAA,CAAS,IAAA;AAAA,IACf,QAAQ,QAAA,CAAS,MAAA;AAAA,IACjB,KAAK,QAAA,CAAS,GAAA;AAAA,IACd,UAAU,QAAA,CAAS,QAAA;AAAA,IACnB,WAAW,QAAA,CAAS,SAAA;AAAA,IACpB,eAAe,QAAA,CAAS,aAAA;AAAA,IACxB,WAAW,QAAA,CAAS,SAAA;AAAA,IACpB,MAAM,QAAA,CAAS,IAAA;AAAA,IACf,iBAAiB,QAAA,CAAS,eAAA;AAAA,IAC1B,UAAU,QAAA,CAAS;AAAA,GACrB;AACA,EAAA,IAAI,UAAA,GAAa,KAAA;AACjB,EAAA,MAAM,2BAA2B,CAAC,MAAA,EAAQ,KAAA,EAAO,UAAA,EAAY,aAAa,WAAW,CAAA;AACrF,EAAA,KAAA,MAAW,OAAO,wBAAA,EAA0B;AAC1C,IAAA,IAAI,KAAA,CAAM,GAAG,CAAA,KAAM,MAAA,IAAa,MAAM,GAAG,CAAA,KAAM,QAAA,CAAS,GAAG,CAAA,EAAG;AAC5D,MAAA,IAAA,CAAK,GAAG,CAAA,GAAI,KAAA,CAAM,GAAG,CAAA;AACrB,MAAA,UAAA,GAAa,IAAA;AAAA,IACf;AAAA,EACF;AAEA,EAAA,IAAI,KAAA,CAAM,aAAa,MAAA,EAAW;AAChC,IAAA,IAAA,CAAK,QAAA,GAAW,EAAE,GAAA,CAAK,EAAA,GAAA,QAAA,CAAS,QAAA,KAAT,YAAqB,EAAC,EAAyB,GAAI,KAAA,CAAM,QAAA,EAA8B;AAC9G,IAAA,UAAA,GAAa,IAAA;AACb,IAAA,UAAA,GAAa,yBAAA,CAA0B,IAAA,EAAM,KAAK,CAAA,IAAK,UAAA;AAAA,EACzD;AAEA,EAAA,OAAO,EAAE,MAAM,UAAA,EAAW;AAC5B;AAEA,MAAM,4BAA4B,CAChC,IAAA,EACA,KAAA,EACA,OAAA,GAAyC,EAAC,KAC9B;AACZ,EAAA,MAAM,OAAA,GAAU,qBAAA,CAAsB,IAAA,EAAM,KAAK,CAAA;AACjD,EAAA,IAAI,QAAQ,eAAA,EAAiB;AAC3B,IAAA,uBAAA,CAAwB,MAAM,KAAK,CAAA;AAAA,EACrC;AACA,EAAA,OAAO,OAAA;AACT,CAAA;AAEA,MAAM,qBAAA,GAAwB,CAAC,IAAA,EAAwB,KAAA,KAAqC;AA7E5F,EAAA,IAAA,EAAA;AA8EE,EAAA,MAAM,QAAA,GAAA,CAAY,EAAA,GAAA,IAAA,CAAK,QAAA,KAAL,IAAA,GAAA,EAAA,GAAkD,EAAC;AACrE,EAAA,IAAI,OAAA,GAAU,KAAA;AAEd,EAAA,KAAA,MAAW,OAAO,kBAAA,EAAoB;AACpC,IAAA,IAAI,QAAA,CAAS,GAAG,CAAA,KAAM,MAAA,EAAW;AAC/B,MAAA;AAAA,IACF;AAEA,IAAA,IAAI,KAAA,CAAM,GAAG,CAAA,KAAM,MAAA,EAAW;AAC5B,MAAA,IAAA,CAAK,GAAG,CAAA,GAAI,QAAA,CAAS,GAAG,CAAA;AACxB,MAAA,OAAA,GAAU,IAAA;AAAA,IACZ;AAEA,IAAA,OAAO,SAAS,GAAG,CAAA;AAAA,EACrB;AAEA,EAAA,IAAA,CAAK,QAAA,GAAW,QAAA;AAChB,EAAA,OAAO,OAAA;AACT,CAAA;AAEA,MAAM,uBAAA,GAA0B,CAAC,IAAA,EAAwB,KAAA,KAAkC;AAlG3F,EAAA,IAAA,EAAA;AAmGE,EAAA,MAAM,QAAA,GAAA,CAAY,EAAA,GAAA,IAAA,CAAK,QAAA,KAAL,IAAA,GAAA,EAAA,GAAkD,EAAC;AAErE,EAAA,IAAI,QAAA,CAAS,eAAe,MAAA,EAAW;AACrC,IAAA,IAAA,CAAK,QAAA,GAAW,QAAA;AAChB,IAAA;AAAA,EACF;AAEA,EAAA,IAAI,QAAA,CAAS,kBAAkB,IAAA,EAAM;AACnC,IAAA,QAAA,CAAS,UAAA,GAAa,eAAA;AAAA,EACxB,WAAW,IAAA,CAAK,SAAA,KAAc,IAAA,IAAQ,KAAA,CAAM,cAAc,IAAA,EAAM;AAC9D,IAAA,QAAA,CAAS,UAAA,GAAa,OAAA;AAAA,EACxB;AAEA,EAAA,IAAA,CAAK,QAAA,GAAW,QAAA;AAClB,CAAA;;;;"}

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

@@ -1,54 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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":"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"}

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

@@ -1,434 +0,0 @@
-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