react-semaphor 0.1.536 → 0.1.538

package/dist/chunks/analytics-base-schemas-BFAoRlkU.js

@@ -0,0 +1,472 @@
+import { z as e } from "zod";
+const T = [
+  "missing_dependency",
+  "missing_relationship",
+  "population_required",
+  "ambiguous_relationship"
+];
+function $(a) {
+  return T.includes(
+    a
+  );
+}
+const W = 200, b = [
+  "second",
+  "minute",
+  "hour",
+  "day",
+  "week",
+  "month",
+  "quarter",
+  "year"
+];
+function X(a) {
+  return typeof a == "string" && b.includes(a);
+}
+const j = [
+  "week_of_short",
+  "week_of_long",
+  "quarter_short",
+  "quarter_long",
+  "fiscal_quarter_short",
+  "fiscal_year"
+], J = {
+  invalidMetadata: "invalid_raw_temporal_metadata"
+};
+function v(a) {
+  return a === "second" || a === "minute" || a === "hour" ? "datetime" : "date";
+}
+const Y = {
+  missingMetadata: "missing_temporal_bucket_metadata",
+  invalidMetadata: "invalid_temporal_bucket_metadata",
+  invalidValue: "invalid_temporal_bucket_value"
+}, Q = "__auto_count__";
+function I(a) {
+  try {
+    return new Intl.DateTimeFormat("en-US", { timeZone: a }).format(), !0;
+  } catch {
+    return !1;
+  }
+}
+const w = e.record(e.string(), e.unknown()), i = e.array(w), r = e.enum([
+  "SUM",
+  "COUNT",
+  "AVG",
+  "MIN",
+  "MAX",
+  "MEDIAN",
+  "DISTINCT"
+]), s = e.enum([
+  "postgres",
+  "mysql",
+  "mssql",
+  "snowflake",
+  "clickhouse",
+  "bigquery",
+  "redshift",
+  "duckdb",
+  "sqlite",
+  "unknown"
+]), C = e.enum(b), l = e.enum([
+  "dimension",
+  "measure",
+  "date",
+  "id",
+  "unknown"
+]), p = e.enum([
+  "string",
+  "number",
+  "boolean",
+  "date",
+  "datetime",
+  "unknown"
+]), u = e.union([e.number(), e.string(), e.null()]), d = e.enum([
+  "millisecond",
+  "second",
+  "minute",
+  "hour",
+  "day"
+]), O = e.enum(j), q = e.discriminatedUnion("mode", [
+  e.object({ mode: e.literal("auto") }).strict(),
+  e.object({
+    mode: e.literal("preset"),
+    preset: O
+  }).strict(),
+  e.object({
+    mode: e.literal("pattern"),
+    pattern: e.string().min(1)
+  }).strict()
+]), ee = e.object({
+  type: e.literal("temporal_bucket"),
+  presentation: q
+}).strict(), A = e.object({
+  tz: e.string().min(1).refine(I, {
+    message: "tz must be a valid IANA timezone"
+  }),
+  weekStart: e.number().int().min(0).max(6),
+  fiscalCalendar: e.object({
+    kind: e.literal("month_aligned"),
+    yearStartMonth: e.number().int().min(1).max(12)
+  }).strict().optional()
+}).strict(), g = e.object({
+  kind: e.literal("temporal_bucket"),
+  granularity: C,
+  calendar: A
+}).strict(), D = e.object({
+  kind: e.literal("raw_temporal"),
+  valueKind: e.enum(["date", "wall_datetime", "instant"])
+}).strict(), E = e.union([
+  e.object({
+    type: e.enum([
+      "number",
+      "currency",
+      "percent",
+      "percentage",
+      "scientific"
+    ]),
+    locale: e.string().optional(),
+    minimumFractionDigits: e.number().optional(),
+    maximumFractionDigits: e.number().optional(),
+    useGrouping: e.boolean().optional(),
+    prefix: e.string().optional(),
+    suffix: e.string().optional(),
+    negativeStyle: e.enum(["minus", "parentheses"]).optional(),
+    compact: e.boolean().optional(),
+    scale: e.number().optional(),
+    currency: e.string().optional(),
+    percentValueMode: e.enum(["fraction", "whole"]).optional()
+  }).passthrough().superRefine((a, t) => {
+    "locale" in a && t.addIssue({
+      code: e.ZodIssueCode.custom,
+      path: ["locale"],
+      message: "Numeric semantic formats inherit locale from viewer preferences."
+    });
+  }),
+  e.object({
+    type: e.enum(["date", "datetime"]),
+    locale: e.string().optional(),
+    pattern: e.string().optional(),
+    relative: e.boolean().optional(),
+    timezone: e.string().optional(),
+    sourceTimezone: e.string().optional(),
+    prefix: e.string().optional(),
+    suffix: e.string().optional()
+  }).passthrough(),
+  e.object({
+    type: e.literal("duration"),
+    inputUnit: d.optional(),
+    outputStyle: e.enum(["compact", "digital", "long"]).optional(),
+    largestUnit: d.optional(),
+    smallestUnit: d.optional(),
+    maxUnits: e.number().optional(),
+    prefix: e.string().optional(),
+    suffix: e.string().optional(),
+    negativeStyle: e.enum(["minus", "parentheses"]).optional()
+  }).passthrough(),
+  e.object({
+    type: e.literal("string"),
+    prefix: e.string().optional(),
+    suffix: e.string().optional()
+  }).passthrough()
+]);
+function M(a, t) {
+  return e.object(a).passthrough().superRefine((o, k) => {
+    for (const m of t)
+      Object.prototype.hasOwnProperty.call(o, m) || k.addIssue({
+        code: "custom",
+        path: [m],
+        message: `Required field "${m}" is missing.`
+      });
+  });
+}
+const y = e.object({
+  kind: e.literal("semantic"),
+  domainId: e.string(),
+  datasetName: e.string(),
+  datasetId: e.string().optional(),
+  label: e.string().optional(),
+  connectionId: e.string().optional()
+}).passthrough(), N = e.object({
+  kind: e.literal("physical"),
+  connectionId: e.string(),
+  connectionType: e.string().optional(),
+  tableName: e.string(),
+  databaseName: e.string().optional(),
+  schemaName: e.string().optional(),
+  label: e.string().optional(),
+  dialect: s.optional()
+}).passthrough(), P = e.object({
+  kind: e.literal("sql"),
+  connectionId: e.string(),
+  dialect: s.optional(),
+  label: e.string().optional()
+}).passthrough(), S = e.union([
+  y,
+  N,
+  P
+]), F = e.object({
+  name: e.string(),
+  label: e.string().optional(),
+  role: l.optional(),
+  dataType: p.optional(),
+  source: S.optional(),
+  aggregate: r.optional()
+}).passthrough(), _ = F, x = e.object({
+  kind: e.literal("field"),
+  field: _,
+  aggregate: r.optional()
+}).passthrough(), B = e.object({
+  kind: e.literal("derived_field"),
+  name: e.string(),
+  label: e.string(),
+  description: e.string().optional(),
+  resultRole: l,
+  dataType: p,
+  computeStage: e.enum(["row", "aggregate"]),
+  expression: e.string(),
+  expressionLanguage: e.literal("semaphor_sql_template").optional(),
+  inputs: e.record(x),
+  defaultAggregate: r.optional(),
+  aggregationBehavior: e.enum([
+    "additive",
+    "non_additive",
+    "ratio_of_sums",
+    "weighted",
+    "pre_aggregated",
+    "snapshot"
+  ]).optional(),
+  aggregationStrategy: e.enum([
+    "default",
+    "symmetric_aggregate",
+    "aggregate_then_join",
+    "weighted"
+  ]).optional(),
+  format: E.optional(),
+  tags: e.array(e.string()).optional()
+}).passthrough(), f = B, ae = _.and(
+  e.object({
+    derivedField: f.optional()
+  }).passthrough()
+), U = y, V = e.object({
+  kind: e.literal("physical"),
+  connectionId: e.string().optional(),
+  connectionType: e.string().optional(),
+  tableName: e.string(),
+  databaseName: e.string().optional(),
+  schemaName: e.string().optional(),
+  label: e.string().optional(),
+  dialect: s.optional()
+}).passthrough(), z = e.object({
+  kind: e.literal("sql"),
+  connectionId: e.string().optional(),
+  dialect: s.optional(),
+  label: e.string().optional()
+}).passthrough(), G = e.union([
+  U,
+  V,
+  z
+]), te = e.object({
+  key: e.string().optional(),
+  name: e.string(),
+  label: e.string().optional(),
+  role: l.optional(),
+  dataType: p.optional(),
+  source: G.optional(),
+  aggregate: r.optional(),
+  derivedField: e.never().optional()
+}).passthrough(), n = e.object({
+  key: e.string(),
+  name: e.string(),
+  label: e.string(),
+  role: l.optional(),
+  dataType: p.optional(),
+  aggregate: r.optional(),
+  source: S.optional(),
+  derivedField: f.optional(),
+  temporalBucket: g.optional(),
+  rawTemporal: D.optional(),
+  pivotIdentity: e.object({
+    metricId: e.string().min(1),
+    metricAlias: e.string().min(1),
+    members: e.array(
+      e.object({
+        fieldId: e.string().min(1),
+        value: e.string().nullable(),
+        temporalBucket: g.optional()
+      }).strict()
+    )
+  }).strict().optional()
+}).passthrough().superRefine((a, t) => {
+  if (a.temporalBucket && a.rawTemporal && t.addIssue({
+    code: e.ZodIssueCode.custom,
+    path: ["rawTemporal"],
+    message: "A result column cannot carry both temporalBucket and rawTemporal metadata."
+  }), a.temporalBucket) {
+    const o = v(
+      a.temporalBucket.granularity
+    );
+    a.dataType !== o && t.addIssue({
+      code: e.ZodIssueCode.custom,
+      path: ["dataType"],
+      message: `${a.temporalBucket.granularity} temporal buckets require dataType ${o}.`
+    });
+  }
+  if (a.rawTemporal) {
+    const o = a.rawTemporal.valueKind === "date" ? "date" : "datetime";
+    a.dataType !== o && t.addIssue({
+      code: e.ZodIssueCode.custom,
+      path: ["dataType"],
+      message: `${a.rawTemporal.valueKind} raw temporal values require dataType ${o}.`
+    });
+  }
+}), oe = e.object({
+  records: i,
+  columns: e.array(n).optional()
+}).passthrough(), ne = e.object({
+  records: i,
+  columns: e.array(n)
+}).passthrough(), R = e.object({
+  code: e.string(),
+  message: e.string().optional(),
+  invalidField: e.string().optional(),
+  fieldRole: e.enum(["measure", "date", "dimension", "input", "source", "sql"]).optional(),
+  validMeasureCandidates: e.array(e.string()).optional(),
+  validDateCandidates: e.array(e.string()).optional(),
+  validDimensionCandidates: e.array(e.string()).optional(),
+  recommendedNextStep: e.string()
+}).passthrough(), h = e.object({
+  code: e.string(),
+  message: e.string(),
+  path: e.string().optional(),
+  fieldRole: e.enum(["measure", "date", "dimension", "input", "source", "sql"]).optional(),
+  repairHint: R.optional()
+}).passthrough(), ie = e.object({
+  ok: e.boolean(),
+  errors: e.array(h),
+  warnings: e.array(h),
+  repairHints: e.array(R)
+}).passthrough(), L = e.object({
+  page: e.number(),
+  pageSize: e.number(),
+  pageCount: e.number(),
+  totalCount: e.number(),
+  hasNextPage: e.boolean(),
+  hasPrevPage: e.boolean()
+}).passthrough(), c = {
+  intentId: e.string().optional(),
+  queryPath: e.enum(["query_spec", "sql", "sql_python"]),
+  warnings: e.array(e.string()).optional(),
+  rowCount: e.number().optional(),
+  rowLimitExceeded: e.boolean().optional(),
+  limit: e.number().optional(),
+  pagination: L.optional()
+}, re = e.object({
+  ...c,
+  kind: e.literal("metric"),
+  primaryValue: u,
+  measures: e.record(u).optional(),
+  missingMeasures: e.array(e.string()).optional(),
+  comparison: e.object({
+    kind: e.enum(["previous_period", "previous_year", "target"]),
+    value: u.optional(),
+    delta: e.union([e.number(), e.null()]).optional(),
+    deltaPercent: e.union([e.number(), e.null()]).optional()
+  }).passthrough().optional(),
+  records: i.optional()
+}).passthrough(), se = e.object({
+  ...c,
+  kind: e.literal("records"),
+  columns: e.array(n),
+  records: i,
+  totals: e.object({
+    mode: e.literal("server"),
+    scope: e.literal("filtered_result"),
+    row: e.record(e.string(), e.unknown()),
+    columns: e.array(n).optional()
+  }).passthrough().optional()
+}).passthrough(), H = e.object({
+  inputId: e.string().min(1),
+  status: e.enum(["applied", "inactive", "skipped", "overridden", "error"]),
+  reason: e.enum([
+    "unrelated",
+    "population_required",
+    "missing_dependency",
+    "missing_relationship",
+    "ambiguous_relationship",
+    "invalid_metadata",
+    "unsupported_dependency",
+    "override_not_eligible"
+  ]).optional()
+}), Z = e.object({
+  complete: e.boolean(),
+  reason: e.enum(["unsupported", "truncated"]).optional()
+}), le = e.object({
+  ...c,
+  kind: e.literal("inputOptions"),
+  dependencyOutcomes: e.array(H).optional(),
+  match: Z.optional(),
+  options: e.array(
+    M(
+      {
+        label: e.string(),
+        value: e.unknown(),
+        count: e.number().optional(),
+        disambiguation: e.array(e.string()).optional()
+      },
+      ["value"]
+    )
+  )
+}).passthrough(), pe = e.object({
+  ...c,
+  kind: e.literal("sql"),
+  columns: e.array(n),
+  records: i,
+  sqlShape: e.object({
+    statementType: e.string().optional(),
+    explicitLimit: e.number().optional(),
+    hasPythonCode: e.boolean().optional()
+  }).passthrough().optional()
+}).passthrough();
+export {
+  oe as A,
+  ne as B,
+  h as C,
+  ie as D,
+  re as E,
+  se as F,
+  H as G,
+  Z as H,
+  le as I,
+  pe as J,
+  W as M,
+  T as O,
+  J as R,
+  Q as S,
+  Y as T,
+  v as a,
+  b,
+  $ as c,
+  X as d,
+  j as e,
+  i as f,
+  r as g,
+  C as h,
+  I as i,
+  ee as j,
+  D as k,
+  E as l,
+  y as m,
+  u as n,
+  N as o,
+  P as p,
+  F as q,
+  w as r,
+  S as s,
+  g as t,
+  _ as u,
+  B as v,
+  f as w,
+  ae as x,
+  te as y,
+  n as z
+};