@altertable/data-app 0.65.0 → 0.67.0

package/dist/chunks/index-ag0cgnvq.js

@@ -0,0 +1,639 @@
+import {
+  formatDateRange2
+} from "./index-mev09s5v.js";
+import {
+  invariant,
+  snapshotQueries,
+  resolveQueryParameters,
+  defineMessageRoute2
+} from "./index-qd5xgx6y.js";
+
+// src/core/contract.ts
+import { parseDate, today } from "@internationalized/date";
+
+// src/core/dimension.ts
+var allSelection = { kind: "all" };
+function dimensionMemberKey(member) {
+  return member.kind === "missing" ? "missing" : `value:${typeof member.value}:${member.value}`;
+}
+function dimensionFilter2(config) {
+  const { key, label, selectionMode, valueType } = config;
+  const options = config.options ?? [];
+  const optionKeys = options.map((option) => dimensionMemberKey({ kind: "value", value: option.value }));
+  invariant(!!key && options.length <= 200 && new Set(optionKeys).size === options.length, "Dimension options need a key, at most 200 distinct values.");
+  invariant(options.every((option) => typeof option.value === valueType && !!option.label.trim() && (option.count === undefined || Number.isSafeInteger(option.count) && option.count >= 0)), "Dimension options need typed values, labels, and nonnegative counts.");
+  const allowed = new Set(optionKeys);
+  const maxSelected = config.maxSelected ?? (selectionMode === "single" ? 1 : 20);
+  invariant(Number.isInteger(maxSelected) && maxSelected >= 1 && maxSelected <= 50 && (selectionMode !== "single" || maxSelected === 1), "Dimension selection limit is invalid.");
+  const allowMissing = config.allowMissing ?? false;
+  const defaultValue = allSelection;
+  function validMember(member) {
+    if (member.kind === "missing")
+      return allowMissing;
+    if (member.kind !== "value" || typeof member.value !== valueType)
+      return false;
+    if (!config.facet)
+      return allowed.has(dimensionMemberKey(member));
+    return typeof member.value === "number" ? Number.isFinite(member.value) : member.value.length <= 100;
+  }
+  function valid(value) {
+    if (!value || typeof value !== "object")
+      return false;
+    if (value.kind === "all")
+      return true;
+    if (value.kind !== "include" && !(config.allowExclusion && value.kind === "exclude") || !Array.isArray(value.members) || !value.members.length || value.members.length > maxSelected)
+      return false;
+    const ids = value.members.map(dimensionMemberKey);
+    return new Set(ids).size === ids.length && value.members.every(validMember);
+  }
+  function encode(value) {
+    return value.kind === "all" ? null : JSON.stringify({
+      kind: value.kind,
+      members: value.members.map((member) => member.kind === "missing" ? ["m"] : ["v", member.value])
+    });
+  }
+  function parse(raw) {
+    if (raw === null)
+      return defaultValue;
+    if (raw.length > 4096)
+      return defaultValue;
+    try {
+      const parsed = JSON.parse(raw);
+      const tokens = Array.isArray(parsed) ? { kind: "include", members: parsed } : parsed;
+      if (!tokens || !Array.isArray(tokens.members))
+        return defaultValue;
+      const value = {
+        kind: tokens.kind,
+        members: tokens.members.map((token) => Array.isArray(token) && token.length === 1 && token[0] === "m" ? { kind: "missing" } : Array.isArray(token) && token.length === 2 && token[0] === "v" ? { kind: "value", value: token[1] } : { kind: "invalid" })
+      };
+      return valid(value) ? value : defaultValue;
+    } catch {
+      return defaultValue;
+    }
+  }
+  return {
+    kind: "dimension",
+    label,
+    valueType,
+    selectionMode,
+    options,
+    facet: config.facet,
+    allowMissing,
+    allowExclusion: config.allowExclusion ?? false,
+    maxSelected,
+    urlKeys: [key],
+    defaultValue,
+    clearValue: allSelection,
+    history: config.history ?? "push",
+    valid,
+    same(left, right) {
+      return encode(left) === encode(right);
+    },
+    read(params) {
+      return parse(params.get(key));
+    },
+    write(value) {
+      return { [key]: encode(value) };
+    },
+    describe(value) {
+      return value.kind === "all" ? `All ${label.toLocaleLowerCase()}` : `${value.kind === "exclude" ? "Exclude: " : ""}${value.members.map((member) => member.kind === "missing" ? "Missing" : options.find((option) => option.value === member.value)?.label ?? String(member.value)).join(", ")}`;
+    }
+  };
+}
+function parseDimensionSelection2(value, filter) {
+  invariant(filter.valid(value), `Invalid ${filter.label} selection.`);
+  return value;
+}
+function parseFacetOptions2(value, filter) {
+  invariant(Array.isArray(value) && value.length <= 200, "Facet options exceed their bound.");
+  const options = [];
+  const seen = new Set;
+  for (const item of value) {
+    invariant(item && typeof item === "object", "Invalid facet option.");
+    const option = item;
+    invariant(typeof option.value === filter.valueType && filter.valid({
+      kind: "include",
+      members: [{ kind: "value", value: option.value }]
+    }) && typeof option.label === "string" && !!option.label.trim() && option.label.length <= 100 && (option.count === undefined || Number.isSafeInteger(option.count) && option.count >= 0), "Invalid facet option.");
+    const id = dimensionMemberKey({ kind: "value", value: option.value });
+    invariant(!seen.has(id), "Duplicate facet option.");
+    seen.add(id);
+    options.push(option);
+  }
+  return options;
+}
+function dimensionPredicate2(column, selection, allowedColumns) {
+  invariant(allowedColumns.includes(column) && /^[A-Za-z_][A-Za-z_0-9]*(?:\.[A-Za-z_][A-Za-z_0-9]*)*$/.test(column), "Invalid dimension column.");
+  if (selection.kind === "all")
+    return "";
+  invariant(selection.members.length > 0, "Empty dimension inclusion is invalid.");
+  const values = selection.members.filter((member) => member.kind === "value");
+  const missing = selection.members.some((member) => member.kind === "missing");
+  const literals = values.map(({ value }) => {
+    if (typeof value === "number") {
+      invariant(Number.isFinite(value), "Invalid numeric dimension value.");
+      return String(value);
+    }
+    const text = value;
+    for (let index = 0;index < text.length; index++)
+      invariant(text.charCodeAt(index) >= 32 && text.charCodeAt(index) !== 127, "Invalid control character in dimension value.");
+    return `'${text.replaceAll("'", "''")}'`;
+  });
+  const clauses = [
+    ...literals.length ? [`${column} IN (${literals.join(", ")})`] : [],
+    ...missing ? [`${column} IS NULL`] : []
+  ];
+  const predicate = `(${clauses.join(" OR ")})`;
+  return selection.kind === "exclude" ? missing ? `NOT ${predicate}` : `(${column} IS NULL OR NOT ${predicate})` : predicate;
+}
+// src/core/annotations.ts
+function object(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error("Invalid annotation.");
+  return value;
+}
+function text(value, limit, required = false) {
+  if (typeof value !== "string" || value.length > limit || required && !value.trim())
+    throw new Error("Invalid annotation text.");
+  return value;
+}
+function names(value) {
+  if (!Array.isArray(value) || value.length > 20)
+    throw new Error("Invalid annotation references.");
+  return value.map((name) => text(name, 128, true));
+}
+function number(value, positive = false) {
+  if (typeof value !== "number" || !Number.isFinite(value) || Math.abs(value) > 1e6 || positive && value < 0)
+    throw new Error("Invalid annotation geometry.");
+  return value;
+}
+function parseDataAppAnnotationDraft2(value) {
+  const input = object(value);
+  const target = object(input.target);
+  const context = object(input.context);
+  const viewport = object(context.viewport);
+  const rect = object(context.rect);
+  if (target.kind !== "widget" && target.kind !== "element" && target.kind !== "app")
+    throw new Error("Invalid annotation target.");
+  let screenshot;
+  if (context.screenshot !== undefined) {
+    const image = object(context.screenshot);
+    const dataUrl = text(image.dataUrl, 350000, true);
+    if (image.mimeType !== "image/png" || !/^data:image\/png;base64,iVBORw0KGgo[A-Za-z0-9+/]*={0,2}$/.test(dataUrl))
+      throw new Error("Invalid annotation screenshot.");
+    const width = number(image.width, true);
+    const height = number(image.height, true);
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1 || width > 1024 || height > 1024)
+      throw new Error("Invalid screenshot dimensions.");
+    const encoded = dataUrl.slice("data:image/png;base64,".length);
+    if (encoded.length % 4 !== 0 || encoded.length / 4 * 3 - (encoded.endsWith("==") ? 2 : encoded.endsWith("=") ? 1 : 0) > 262144)
+      throw new Error("Screenshot is too large.");
+    const header = atob(encoded.slice(0, 44));
+    if (header.length < 24 || header.slice(12, 16) !== "IHDR")
+      throw new Error("Invalid PNG header.");
+    const bytes = Uint8Array.from(header, (character) => character.charCodeAt(0));
+    const dimensions = new DataView(bytes.buffer);
+    if (dimensions.getUint32(16) !== width || dimensions.getUint32(20) !== height)
+      throw new Error("Screenshot dimensions do not match the image.");
+    screenshot = { mimeType: "image/png", dataUrl, width, height };
+  }
+  let anchor;
+  if (context.anchor !== undefined) {
+    const point = object(context.anchor);
+    const x = number(point.x, true);
+    const y = number(point.y, true);
+    if (x > 1 || y > 1)
+      throw new Error("Invalid annotation anchor.");
+    anchor = { x, y };
+  }
+  let cursor;
+  if (context.cursor !== undefined) {
+    const point = object(context.cursor);
+    cursor = { x: number(point.x), y: number(point.y) };
+  }
+  let region;
+  if (context.region !== undefined) {
+    const area = object(context.region);
+    region = {
+      x: number(area.x, true),
+      y: number(area.y, true),
+      width: number(area.width, true),
+      height: number(area.height, true)
+    };
+    if (target.kind !== "app" || region.width <= 0 || region.height <= 0 || region.x + region.width > 1.000001 || region.y + region.height > 1.000001)
+      throw new Error("Invalid annotation selection.");
+  }
+  const draft = {
+    id: text(input.id, 128, true),
+    target: {
+      id: text(target.id, 128, true),
+      label: text(target.label, 256, true),
+      kind: target.kind,
+      text: text(target.text, 1024),
+      queryNames: names(target.queryNames),
+      glossaryIds: names(target.glossaryIds)
+    },
+    context: {
+      ...anchor ? { anchor } : {},
+      ...region ? { region } : {},
+      ...cursor ? { cursor } : {},
+      ...screenshot ? { screenshot } : {},
+      search: text(context.search, 2048),
+      hash: text(context.hash, 1024),
+      viewport: {
+        width: number(viewport.width, true),
+        height: number(viewport.height, true)
+      },
+      rect: {
+        x: number(rect.x),
+        y: number(rect.y),
+        width: number(rect.width, true),
+        height: number(rect.height, true)
+      },
+      ...context.view === undefined ? {} : { view: text(context.view, 128) },
+      ...context.displayedInput === undefined ? {} : { displayedInput: context.displayedInput }
+    },
+    comment: text(input.comment, 2000, true).trim()
+  };
+  const json = JSON.stringify({
+    ...draft,
+    context: { ...draft.context, screenshot: undefined }
+  });
+  if (new TextEncoder().encode(json).byteLength > 12000)
+    throw new Error("Annotation is too large.");
+  return JSON.parse(JSON.stringify(draft));
+}
+var annotationDraftRoute2 = /* @__PURE__ */ defineMessageRoute2({
+  input: parseDataAppAnnotationDraft2,
+  output(value) {
+    if (value !== null)
+      throw new Error("Invalid annotation response.");
+    return null;
+  }
+});
+var annotationEditorStateRoute2 = /* @__PURE__ */ defineMessageRoute2({
+  input(value) {
+    const input = object(value);
+    if (typeof input.hasUnsavedChanges !== "boolean")
+      throw new Error("Invalid annotation editor state.");
+    return { hasUnsavedChanges: input.hasUnsavedChanges };
+  },
+  output(value) {
+    if (value !== null)
+      throw new Error("Invalid annotation response.");
+    return null;
+  }
+});
+var annotationSendRoute2 = /* @__PURE__ */ defineMessageRoute2({
+  input(value) {
+    if (value !== null)
+      throw new Error("Invalid annotation send request.");
+    return null;
+  },
+  output(value) {
+    if (value !== null)
+      throw new Error("Invalid annotation response.");
+    return null;
+  }
+});
+var annotationUpdateRoute2 = /* @__PURE__ */ defineMessageRoute2({
+  input(value) {
+    const input = object(value);
+    return {
+      id: text(input.id, 128, true),
+      comment: text(input.comment, 2000, true).trim()
+    };
+  },
+  output(value) {
+    if (value !== null)
+      throw new Error("Invalid annotation response.");
+    return null;
+  }
+});
+var annotationModeRoute2 = /* @__PURE__ */ defineMessageRoute2({
+  input(value) {
+    const input = object(value);
+    if (typeof input.active !== "boolean")
+      throw new Error("Invalid annotation mode.");
+    return { active: input.active };
+  },
+  output(value) {
+    if (value !== null)
+      throw new Error("Invalid annotation response.");
+    return null;
+  }
+});
+function isAnnotationPresentation(value) {
+  if (!value || typeof value !== "object")
+    return false;
+  const input = value;
+  return typeof input.enabled === "boolean" && (input.active === undefined || typeof input.active === "boolean") && (input.pinsVisible === undefined || typeof input.pinsVisible === "boolean") && (input.showHint === undefined || typeof input.showHint === "boolean") && (input.readOnly === undefined || typeof input.readOnly === "boolean") && (input.selectedAnnotationId === undefined || typeof input.selectedAnnotationId === "string" && input.selectedAnnotationId.length <= 128) && (input.selectionId === undefined || typeof input.selectionId === "string" && input.selectionId.length <= 128) && (input.selectedTargetId === undefined || typeof input.selectedTargetId === "string" && input.selectedTargetId.length <= 128) && (input.targets === undefined || Array.isArray(input.targets) && input.targets.length <= 50 && input.targets.every((target) => target && typeof target.id === "string" && target.id.length <= 128 && typeof target.targetId === "string" && target.targetId.length <= 128 && Number.isSafeInteger(target.number) && target.number > 0 && (target.anchor === undefined || typeof target.anchor.x === "number" && Number.isFinite(target.anchor.x) && target.anchor.x >= 0 && target.anchor.x <= 1 && typeof target.anchor.y === "number" && Number.isFinite(target.anchor.y) && target.anchor.y >= 0 && target.anchor.y <= 1) && (target.region === undefined || typeof target.region === "object" && target.region !== null && ["x", "y", "width", "height"].every((key) => {
+    const value = target.region[key];
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+  }) && target.region.width > 0 && target.region.height > 0 && target.region.x + target.region.width <= 1.000001 && target.region.y + target.region.height <= 1.000001) && (target.comment === undefined || typeof target.comment === "string" && target.comment.length <= 2000)));
+}
+// src/core/filters.ts
+var all = { kind: "all" };
+var numberOperatorLabels = {
+  eq: "Equals",
+  ne: "Does not equal",
+  gt: "Greater than",
+  gte: "At least",
+  lt: "Less than",
+  lte: "At most"
+};
+function numberFilter2({
+  key,
+  label,
+  min,
+  max,
+  defaultValue = all,
+  history = "push"
+}) {
+  invariant(!!key.trim(), "Numeric filter requires a URL key.");
+  invariant((min === undefined || Number.isFinite(min)) && (max === undefined || Number.isFinite(max)) && (min === undefined || max === undefined || min <= max), "Invalid numeric filter bounds.");
+  function validNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && (min === undefined || value >= min) && (max === undefined || value <= max);
+  }
+  function valid(value) {
+    if (!value || typeof value !== "object")
+      return false;
+    if (value.kind === "all")
+      return true;
+    if (value.kind === "comparison")
+      return typeof value.operator === "string" && Object.hasOwn(numberOperatorLabels, value.operator) && validNumber(value.value);
+    return value.kind === "range" && (value.min !== undefined || value.max !== undefined) && (value.min === undefined || validNumber(value.min)) && (value.max === undefined || validNumber(value.max)) && (value.min === undefined || value.max === undefined || value.min <= value.max);
+  }
+  function encode(value) {
+    return value.kind === "all" ? null : value.kind === "range" ? JSON.stringify({ kind: "range", min: value.min, max: value.max }) : JSON.stringify({
+      kind: "comparison",
+      operator: value.operator,
+      value: value.value
+    });
+  }
+  invariant(valid(defaultValue), `Invalid default for ${label}.`);
+  return {
+    kind: "numberFilter",
+    label,
+    min,
+    max,
+    defaultValue,
+    clearValue: all,
+    urlKeys: [key],
+    history,
+    valid,
+    same: (left, right) => encode(left) === encode(right),
+    describe(value) {
+      return value.kind === "all" ? "Any" : value.kind === "comparison" ? `${numberOperatorLabels[value.operator]} ${value.value}` : value.min === undefined ? `At most ${value.max}` : value.max === undefined ? `At least ${value.min}` : `${value.min}–${value.max}`;
+    },
+    read(params) {
+      const raw = params.get(key);
+      if (raw === null)
+        return defaultValue;
+      if (raw.length > 512)
+        return defaultValue;
+      try {
+        const value = raw === "all" ? all : JSON.parse(raw);
+        return valid(value) ? value : defaultValue;
+      } catch {
+        return defaultValue;
+      }
+    },
+    write(value) {
+      return {
+        [key]: encode(value) === encode(defaultValue) ? null : value.kind === "all" ? "all" : encode(value)
+      };
+    }
+  };
+}
+function booleanFilter2({
+  key,
+  label,
+  defaultValue = all,
+  history = "push"
+}) {
+  invariant(!!key.trim(), "Boolean filter requires a URL key.");
+  function valid(value) {
+    return !!value && typeof value === "object" && (value.kind === "all" || value.kind === "is" && typeof value.value === "boolean");
+  }
+  function encode(value) {
+    return value.kind === "all" ? "all" : String(value.value);
+  }
+  invariant(valid(defaultValue), `Invalid default for ${label}.`);
+  return {
+    kind: "booleanFilter",
+    label,
+    defaultValue,
+    clearValue: all,
+    urlKeys: [key],
+    history,
+    valid,
+    describe: (value) => value.kind === "all" ? "Any" : value.value ? "Yes" : "No",
+    same: (left, right) => encode(left) === encode(right),
+    read(params) {
+      const raw = params.get(key);
+      return raw === "all" ? all : raw === "true" || raw === "false" ? { kind: "is", value: raw === "true" } : defaultValue;
+    },
+    write(value) {
+      return {
+        [key]: encode(value) === encode(defaultValue) ? null : encode(value)
+      };
+    }
+  };
+}
+function parseNumberSelection2(value, filter) {
+  invariant(filter.valid(value), `Invalid ${filter.label} selection.`);
+  return value;
+}
+function parseBooleanSelection2(value, filter) {
+  invariant(filter.valid(value), `Invalid ${filter.label} selection.`);
+  return value;
+}
+
+// src/core/contract.ts
+function parseEmptyInput2(value) {
+  invariant(typeof value === "object" && value !== null && !Array.isArray(value) && Object.keys(value).length === 0, "This operation takes no inputs.");
+  return {};
+}
+function parseTrue2(value) {
+  invariant(value === true, "Expected a successful check.");
+  return true;
+}
+function previousDateRange2({
+  start,
+  end
+}) {
+  const first = parseDate(start);
+  const last = parseDate(end);
+  const days = (last.toDate("UTC").getTime() - first.toDate("UTC").getTime()) / 86400000 + 1;
+  invariant(days >= 1, "Date range must start before it ends.");
+  const previousEnd = first.subtract({ days: 1 });
+  return {
+    start: previousEnd.subtract({ days: days - 1 }).toString(),
+    end: previousEnd.toString()
+  };
+}
+function defineDateRangeContract2(options) {
+  invariant(Number.isInteger(options.maxRangeDays) && options.maxRangeDays > 0, "Date range needs a positive maxRangeDays.");
+  if (options.minDate)
+    parseDate(options.minDate);
+  if (typeof options.maxDate === "string")
+    parseDate(options.maxDate);
+  today(options.timeZone);
+  function bounds() {
+    const latest = today(options.timeZone).subtract({
+      days: options.completeDays === false ? 0 : 1
+    });
+    const sourceMax = typeof options.maxDate === "function" ? options.maxDate() : options.maxDate;
+    const maxDate = sourceMax && parseDate(sourceMax).compare(latest) < 0 ? parseDate(sourceMax).toString() : latest.toString();
+    return {
+      minDate: options.minDate,
+      maxDate,
+      maxRangeDays: options.maxRangeDays,
+      timeZone: options.timeZone
+    };
+  }
+  function period({ start, end }) {
+    return {
+      kind: "calendar",
+      start,
+      end,
+      timeZone: options.timeZone
+    };
+  }
+  function describeInput(input) {
+    return `${formatDateRange2(input)} ${options.timeZone}`;
+  }
+  function comparison(input) {
+    const previous = previousDateRange2(input);
+    return options.minDate && previous.start < options.minDate ? null : previous;
+  }
+  function request(value, compare = false) {
+    const range = parseDateRangeInput2(value, bounds());
+    const previous = compare ? comparison(range) : null;
+    invariant(!compare || previous, "Comparison is outside available source coverage.");
+    return { range, comparison: previous };
+  }
+  function parseRequest(value) {
+    invariant(value && typeof value === "object", "Choose a date range.");
+    const input = value;
+    const parsed = request(input.range, input.comparison != null);
+    if (input.comparison != null) {
+      const supplied = parseDateRangeInput2(input.comparison, bounds());
+      invariant(supplied.start === parsed.comparison?.start && supplied.end === parsed.comparison?.end, "Comparison must be the preceding equal-length range.");
+    }
+    return parsed;
+  }
+  return {
+    request,
+    parseRequest,
+    bounds,
+    parse(value) {
+      return parseDateRangeInput2(value, bounds());
+    },
+    period,
+    comparison,
+    describeInput,
+    view: { period, describeInput }
+  };
+}
+function parseDateRangeInput2(value, {
+  minDate,
+  maxDate,
+  maxRangeDays
+}) {
+  invariant(value && typeof value === "object" && !Array.isArray(value), "Choose a date range.");
+  const { start, end } = value;
+  function day(input) {
+    invariant(typeof input === "string" && /^\d{4}-\d{2}-\d{2}$/.test(input), "Dates must be YYYY-MM-DD.");
+    const timestamp = Date.parse(`${input}T00:00:00Z`);
+    invariant(Number.isFinite(timestamp) && new Date(timestamp).toISOString().slice(0, 10) === input, "Choose valid calendar dates.");
+    return timestamp;
+  }
+  const first = day(start);
+  const last = day(end);
+  invariant(Number.isInteger(maxRangeDays) && maxRangeDays > 0, "Maximum range days must be positive.");
+  invariant(first <= last && (last - first) / 86400000 < maxRangeDays && (minDate === undefined || first >= day(minDate)) && (maxDate === undefined || last <= day(maxDate)), `Choose up to ${maxRangeDays} days within the available range.`);
+  return { start, end };
+}
+function parseCount2(value) {
+  const number = typeof value === "number" || typeof value === "string" ? Number(value) : NaN;
+  invariant(Number.isSafeInteger(number) && number >= 0 && (typeof value !== "string" || !!value.trim()), "Invalid count in query result.");
+  return number;
+}
+function parseLabel2(value, maxLength = 100) {
+  invariant(typeof value === "string" && !!value && value.length <= maxLength, "Invalid label in query result.");
+  return value;
+}
+function rowsAsRecords2(result, requiredColumns) {
+  const names = result.columns.map((column) => column.name);
+  invariant(new Set(names).size === names.length && requiredColumns.every((name) => names.includes(name)), "Query result columns do not match the expected shape.");
+  return result.rows.map((row) => {
+    invariant(row.length === names.length, "Query result row has the wrong width.");
+    return Object.fromEntries(names.map((name, index) => [name, row[index]]));
+  });
+}
+function defineQueryNames2(names) {
+  const values = Object.values(names);
+  invariant(values.every((name) => !!name.trim()) && new Set(values).size === values.length, "Query names must be nonempty and unique.");
+  return names;
+}
+var sourceErrorBrand = Symbol.for("@altertable/data-app/DataSourceError");
+
+class DataSourceError2 extends Error {
+  reason;
+  status;
+  [sourceErrorBrand] = true;
+  queryName;
+  static [Symbol.hasInstance](value) {
+    return value instanceof Error && value[sourceErrorBrand] === true;
+  }
+  constructor(reason, status) {
+    super(`Data source ${reason}${status ? ` (${status})` : ""}.`);
+    this.reason = reason;
+    this.status = status;
+    this.name = "DataSourceError";
+  }
+}
+function defineOperation2(operation) {
+  invariant(Array.isArray(operation.checks) && operation.checks.length > 0 && Number.isInteger(operation.policy.maxQueryRows) && operation.policy.maxQueryRows > 0 && Number.isInteger(operation.policy.maxDurationMs) && operation.policy.maxDurationMs > 0 && (operation.policy.maxResponseBytes === undefined || Number.isInteger(operation.policy.maxResponseBytes) && operation.policy.maxResponseBytes > 0), "Each data operation needs check inputs and positive row and duration limits.");
+  const queries = snapshotQueries(operation.queries);
+  const queryNames = Object.fromEntries(Object.keys(queries).map((name) => [name, name]));
+  for (const input of operation.checks)
+    operation.input(input);
+  return {
+    ...operation,
+    queryNames,
+    run(context, input) {
+      function query(name, values = {}, options) {
+        invariant(Object.hasOwn(queries, name), `Unknown query name: ${name}.`);
+        const definition = queries[name];
+        const params = resolveQueryParameters(definition.params, values, context.queryParams ?? {});
+        return context.lakehouse.queryAll(definition.statement, {
+          name,
+          params,
+          limit: options?.limit ?? operation.policy.maxQueryRows,
+          signal: context.signal
+        });
+      }
+      return operation.run({ signal: context.signal, query }, input);
+    }
+  };
+}
+function connectionCheck2(queries) {
+  return defineOperation2({
+    queries,
+    input: parseEmptyInput2,
+    output: parseTrue2,
+    checks: [{}],
+    policy: { maxQueryRows: 1, maxDurationMs: 15000 },
+    async run({ query }) {
+      await query("connection");
+      return true;
+    }
+  });
+}
+
+export { dimensionMemberKey, dimensionFilter2, parseDimensionSelection2, parseFacetOptions2, dimensionPredicate2, parseDataAppAnnotationDraft2, annotationDraftRoute2, annotationEditorStateRoute2, annotationSendRoute2, annotationUpdateRoute2, annotationModeRoute2, isAnnotationPresentation, numberOperatorLabels, numberFilter2, booleanFilter2, parseNumberSelection2, parseBooleanSelection2, parseEmptyInput2, parseTrue2, previousDateRange2, defineDateRangeContract2, parseDateRangeInput2, parseCount2, parseLabel2, rowsAsRecords2, defineQueryNames2, DataSourceError2, defineOperation2, connectionCheck2 };
+
+//# debugId=87015EDE1552300964756E2164756E21