@uwdata/mosaic-inputs 0.0.1

package/dist/mosaic-inputs.js

@@ -0,0 +1,1299 @@
+// ../core/src/MosaicClient.js
+var MosaicClient = class {
+  constructor(filterSelection) {
+    this._filterBy = filterSelection;
+  }
+  get filterBy() {
+    return this._filterBy;
+  }
+  get filterIndexable() {
+    return true;
+  }
+  fields() {
+    return null;
+  }
+  fieldStats() {
+    return this;
+  }
+  query() {
+    return null;
+  }
+  queryPending() {
+    return this;
+  }
+  queryResult() {
+    return this;
+  }
+  queryError(error) {
+    console.error(error);
+    return this;
+  }
+  update() {
+    return this;
+  }
+};
+
+// ../sql/src/ref.js
+var Ref = class {
+  constructor(table, column2) {
+    if (table)
+      this.table = String(table);
+    if (column2)
+      this.column = column2;
+  }
+  get columns() {
+    return this.column ? [this.column] : [];
+  }
+  toString() {
+    const { table, column: column2 } = this;
+    if (column2) {
+      const col = column2 === "*" ? column2 : `"${column2}"`;
+      return (table ? `"${table}".` : "") + col;
+    } else {
+      return `"${table}"`;
+    }
+  }
+};
+function isColumnRefFor(ref, name) {
+  return ref instanceof Ref && ref.column === name;
+}
+function asColumn(value) {
+  return typeof value === "string" ? column(value) : value;
+}
+function asRelation(value) {
+  return typeof value === "string" ? relation(value) : value;
+}
+function relation(name) {
+  return new Ref(name);
+}
+function column(table, column2) {
+  return arguments.length === 1 ? new Ref(null, table) : new Ref(table, column2);
+}
+function desc(expr2) {
+  expr2 = asColumn(expr2);
+  return {
+    expr: expr2,
+    desc: true,
+    toString: () => `${expr2} DESC NULLS LAST`,
+    get columns() {
+      return expr2.columns?.() || [];
+    }
+  };
+}
+function expr(sql, columns, label) {
+  return {
+    expr: sql,
+    label,
+    toString: () => `${sql}`,
+    get columns() {
+      return columns || [];
+    }
+  };
+}
+function transform(func2, label) {
+  return (value) => expr(
+    func2(value),
+    asColumn(value).columns,
+    label
+  );
+}
+
+// ../sql/src/to-sql.js
+function toSQL(value) {
+  return typeof value === "string" ? `"${value}"` : literalToSQL(value);
+}
+function literalToSQL(value) {
+  switch (typeof value) {
+    case "boolean":
+      return value ? "TRUE" : "FALSE";
+    case "string":
+      return `'${value}'`;
+    default:
+      if (value == null) {
+        return "NULL";
+      } else if (value instanceof Date) {
+        return `MAKE_DATE(${value.getUTCFullYear()}, ${value.getUTCMonth() + 1}, ${value.getUTCDate()})`;
+      } else if (value instanceof RegExp) {
+        return `'${value.source}'`;
+      } else {
+        return String(value);
+      }
+  }
+}
+
+// ../sql/src/literal.js
+var Literal = class {
+  constructor(value) {
+    this.value = value;
+  }
+  toString() {
+    return literalToSQL(this.value);
+  }
+};
+var literal = (value) => new Literal(value);
+
+// ../sql/src/compare.js
+function extractColumns(...args) {
+  return args.flat().flatMap((arg) => arg?.columns || []);
+}
+var Compare1 = class {
+  constructor(op, a) {
+    this.op = op;
+    this.a = asColumn(a);
+  }
+  get columns() {
+    return extractColumns(this.a);
+  }
+  visit(callback) {
+    callback(this.op, this);
+  }
+  toString() {
+    const { op, a } = this;
+    return `(${toSQL(a)} ${op})`;
+  }
+};
+function compare1(op) {
+  return (a) => new Compare1(op, a);
+}
+var not = compare1("NOT");
+var isNull = compare1("IS NULL");
+var isNotNull = compare1("IS NOT NULL");
+var Compare2 = class {
+  constructor(op, a, b) {
+    this.op = op;
+    this.a = asColumn(a);
+    this.b = asColumn(b);
+  }
+  get columns() {
+    return extractColumns(this.a, this.b);
+  }
+  visit(callback) {
+    callback(this.op, this);
+  }
+  toString() {
+    const { op, a, b } = this;
+    return `(${toSQL(a)} ${op} ${toSQL(b)})`;
+  }
+};
+function compare2(op) {
+  return (a, b) => new Compare2(op, a, b);
+}
+var eq = compare2("=");
+var neq = compare2("<>");
+var lt = compare2("<");
+var gt = compare2(">");
+var lte = compare2("<=");
+var gte = compare2(">=");
+var isDistinct = compare2("IS DISTINCT FROM");
+var isNotDistinct = compare2("IS NOT DISTINCT FROM");
+var Range = class {
+  constructor(op, expr2, value) {
+    this.op = op;
+    this.expr = asColumn(expr2);
+    this.value = value?.map(asColumn);
+  }
+  get columns() {
+    return extractColumns(this.expr, this.value);
+  }
+  visit(callback) {
+    callback(this.op, this);
+  }
+  toString() {
+    const { op, expr: expr2, value } = this;
+    if (!value)
+      return "";
+    const [a, b] = value;
+    return `(${toSQL(expr2)} ${op} ${toSQL(a)} AND ${toSQL(b)})`;
+  }
+};
+function range(op) {
+  return (a, range2) => new Range(op, a, range2);
+}
+var isBetween = range("BETWEEN");
+var isNotBetween = range("NOT BETWEEN");
+var CompareN = class {
+  constructor(op, value) {
+    this.op = op;
+    this.value = value.map(asColumn);
+  }
+  get columns() {
+    return extractColumns(this.value);
+  }
+  visit(callback) {
+    callback(this.op, this);
+    this.value?.forEach((v) => v.visit(callback));
+  }
+  toString() {
+    const { op, value } = this;
+    return !value || value.length === 0 ? "" : value.length === 1 ? toSQL(value[0]) : `(${value.map(toSQL).filter((x) => x).join(` ${op} `)})`;
+  }
+};
+function or(...clauses) {
+  return new CompareN("OR", clauses.flat());
+}
+
+// ../sql/src/function-call.js
+var FunctionCall = class {
+  constructor(func2, args) {
+    this.func = func2;
+    this.args = (args || []).map(asColumn);
+  }
+  get column() {
+    return this.columns[0];
+  }
+  get columns() {
+    return this.args.flatMap((a) => a.columns || []);
+  }
+  toString() {
+    const { func: func2, args } = this;
+    return `${func2}(${args.map(toSQL).join(", ")})`;
+  }
+};
+function func(op) {
+  return (...args) => new FunctionCall(op, args);
+}
+var regexp_matches = func("regexp_matches");
+var contains = func("contains");
+var prefix = func("prefix");
+var suffix = func("suffix");
+var lower = func("lower");
+var upper = func("upper");
+var length = func("length");
+var isNaN2 = func("isnan");
+var isFinite = func("isfinite");
+var isInfinite = func("isinf");
+
+// ../sql/src/aggregate.js
+var Aggregate = class {
+  constructor(op, args) {
+    this.aggregate = op;
+    this.args = (args || []).map(asColumn);
+  }
+  get label() {
+    return this.aggregate.toLowerCase() + (this.args.length ? ` ${this.columns.join(", ")}` : "");
+  }
+  get column() {
+    return this.columns[0];
+  }
+  get columns() {
+    return this.args.flatMap((a) => a.columns || []);
+  }
+  distinct() {
+    this.isDistinct = true;
+    return this;
+  }
+  where(expr2) {
+    this.filter = expr2;
+    return this;
+  }
+  toString() {
+    const { aggregate, args, isDistinct: isDistinct2, filter } = this;
+    const arg = args.length === 0 ? "*" : args.map(toSQL).join(", ");
+    const distinct = isDistinct2 ? "DISTINCT " : "";
+    const where = filter ? ` FILTER (WHERE ${toSQL(filter)})` : "";
+    const cast = aggregate === "COUNT" ? "::INTEGER" : "";
+    return where && cast ? `(${aggregate}(${distinct}${arg})${where})${cast}` : `${aggregate}(${distinct}${arg})${where}${cast}`;
+  }
+};
+function agg(op) {
+  return (...args) => new Aggregate(op, args);
+}
+var count = agg("COUNT");
+var avg = agg("AVG");
+var mean = agg("AVG");
+var mad = agg("MAD");
+var max = agg("MAX");
+var min = agg("MIN");
+var sum = agg("SUM");
+var product = agg("PRODUCT");
+var median = agg("MEDIAN");
+var quantile = agg("QUANTILE");
+var mode = agg("MODE");
+var variance = agg("VARIANCE");
+var stddev = agg("STDDEV");
+var skewness = agg("SKEWNESS");
+var kurtosis = agg("KURTOSIS");
+var entropy = agg("ENTROPY");
+var varPop = agg("VAR_POP");
+var stddevPop = agg("STDDEV_POP");
+var corr = agg("CORR");
+var covarPop = agg("COVAR_POP");
+var regrIntercept = agg("REGR_INTERCEPT");
+var regrSlope = agg("REGR_SLOPE");
+var regrCount = agg("REGR_COUNT");
+var regrR2 = agg("REGR_R2");
+var regrSYY = agg("REGR_SYY");
+var regrSXX = agg("REGR_SXX");
+var regrSXY = agg("REGR_SXY");
+var regrAvgX = agg("REGR_AVGX");
+var regrAvgY = agg("REGR_AVGY");
+var first = agg("FIRST");
+var last = agg("LAST");
+var argmin = agg("ARG_MIN");
+var argmax = agg("ARG_MAX");
+var stringAgg = agg("STRING_AGG");
+var arrayAgg = agg("ARRAY_AGG");
+
+// ../sql/src/datetime.js
+var epoch_ms = transform(
+  (d) => `(1000 * (epoch(${d}) - second(${d})) + millisecond(${d}))::DOUBLE`
+);
+
+// ../sql/src/Query.js
+var Query = class {
+  static select(...expr2) {
+    return new Query().select(...expr2);
+  }
+  static from(...expr2) {
+    return new Query().from(...expr2);
+  }
+  static with(...expr2) {
+    return new Query().with(...expr2);
+  }
+  static union(...queries) {
+    return new SetOperation("UNION", queries.flat());
+  }
+  static unionAll(...queries) {
+    return new SetOperation("UNION ALL", queries.flat());
+  }
+  static intersect(...queries) {
+    return new SetOperation("INTERSECT", queries.flat());
+  }
+  static except(...queries) {
+    return new SetOperation("EXCEPT", queries.flat());
+  }
+  constructor() {
+    this.query = {
+      with: [],
+      select: [],
+      from: [],
+      where: [],
+      groupby: [],
+      having: [],
+      window: [],
+      qualify: [],
+      orderby: []
+    };
+  }
+  clone() {
+    const q = new Query();
+    q.query = { ...this.query };
+    return q;
+  }
+  with(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.with;
+    } else {
+      const list = [];
+      const add = (as, q) => {
+        const query2 = q.clone();
+        query2.cteFor = this;
+        list.push({ as, query: query2 });
+      };
+      expr2.flat().forEach((e) => {
+        if (e == null) {
+        } else if (e.as && e.query) {
+          add(e.as, e.query);
+        } else {
+          for (const as in e) {
+            add(as, e[as]);
+          }
+        }
+      });
+      query.with = query.with.concat(list);
+      return this;
+    }
+  }
+  select(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.select;
+    } else {
+      const list = [];
+      expr2.flat().forEach((e) => {
+        if (e == null) {
+        } else if (typeof e === "string") {
+          list.push({ as: e, expr: asColumn(e) });
+        } else if (e instanceof Ref) {
+          list.push({ as: e.column, expr: e });
+        } else if (Array.isArray(e)) {
+          list.push({ as: e[0], expr: e[1] });
+        } else {
+          for (const as in e) {
+            list.push({ as: unquote(as), expr: asColumn(e[as]) });
+          }
+        }
+      });
+      query.select = query.select.concat(list);
+      return this;
+    }
+  }
+  $select(...expr2) {
+    this.query.select = [];
+    return this.select(...expr2);
+  }
+  distinct(value = true) {
+    this.query.distinct = !!value;
+    return this;
+  }
+  from(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.from;
+    } else {
+      const list = [];
+      expr2.flat().forEach((e) => {
+        if (e == null) {
+        } else if (typeof e === "string") {
+          list.push({ as: e, from: asRelation(e) });
+        } else if (e instanceof Ref) {
+          list.push({ as: e.table, from: e });
+        } else if (isQuery(e) || Object.hasOwn(e, "toString")) {
+          list.push({ from: e });
+        } else if (Array.isArray(e)) {
+          list.push({ as: unquote(e[0]), from: asRelation(e[1]) });
+        } else {
+          for (const as in e) {
+            list.push({ as: unquote(as), from: asRelation(e[as]) });
+          }
+        }
+      });
+      query.from = query.from.concat(list);
+      return this;
+    }
+  }
+  $from(...expr2) {
+    this.query.from = [];
+    return this.from(...expr2);
+  }
+  sample(value) {
+    const { query } = this;
+    if (arguments.length === 0) {
+      return query.sample;
+    } else {
+      let spec = value;
+      if (typeof value === "number") {
+        spec = value > 0 && value < 1 ? { perc: 100 * value } : { rows: Math.round(value) };
+      }
+      query.sample = spec;
+      return this;
+    }
+  }
+  where(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.where;
+    } else {
+      query.where = query.where.concat(
+        expr2.flat().filter((x) => x)
+      );
+      return this;
+    }
+  }
+  $where(...expr2) {
+    this.query.where = [];
+    return this.where(...expr2);
+  }
+  groupby(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.groupby;
+    } else {
+      query.groupby = query.groupby.concat(
+        expr2.flat().filter((x) => x).map(asColumn)
+      );
+      return this;
+    }
+  }
+  having(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.having;
+    } else {
+      query.having = query.having.concat(
+        expr2.flat().filter((x) => x)
+      );
+      return this;
+    }
+  }
+  window(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.window;
+    } else {
+      const list = [];
+      expr2.flat().forEach((e) => {
+        if (e == null) {
+        } else {
+          for (const as in e) {
+            list.push({ as: unquote(as), expr: e[as] });
+          }
+        }
+      });
+      query.window = query.window.concat(list);
+      return this;
+    }
+  }
+  qualify(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.qualify;
+    } else {
+      query.qualify = query.qualify.concat(
+        expr2.flat().filter((x) => x)
+      );
+      return this;
+    }
+  }
+  orderby(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.orderby;
+    } else {
+      query.orderby = query.orderby.concat(
+        expr2.flat().filter((x) => x).map(asColumn)
+      );
+      return this;
+    }
+  }
+  limit(value) {
+    const { query } = this;
+    if (arguments.length === 0) {
+      return query.limit;
+    } else {
+      query.limit = Number.isFinite(value) ? value : void 0;
+      return this;
+    }
+  }
+  offset(value) {
+    const { query } = this;
+    if (arguments.length === 0) {
+      return query.offset;
+    } else {
+      query.offset = Number.isFinite(value) ? value : void 0;
+      return this;
+    }
+  }
+  get subqueries() {
+    const { query, cteFor } = this;
+    const ctes = (cteFor?.query || query).with;
+    const cte = ctes?.reduce((o, { as, query: query2 }) => (o[as] = query2, o), {});
+    const q = [];
+    query.from.forEach(({ from }) => {
+      if (isQuery(from)) {
+        q.push(from);
+      } else if (cte[from.table]) {
+        const sub = cte[from.table];
+        q.push(sub);
+      }
+    });
+    return q;
+  }
+  toString() {
+    const {
+      select,
+      distinct,
+      from,
+      sample,
+      where,
+      groupby,
+      having,
+      window,
+      qualify,
+      orderby,
+      limit,
+      offset,
+      with: cte
+    } = this.query;
+    const sql = [];
+    if (cte.length) {
+      const list = cte.map(({ as, query }) => `"${as}" AS (${query})`);
+      sql.push(`WITH ${list.join(", ")}`);
+    }
+    const sels = select.map(
+      ({ as, expr: expr2 }) => isColumnRefFor(expr2, as) && !expr2.table ? `${expr2}` : `${expr2} AS "${as}"`
+    );
+    sql.push(`SELECT${distinct ? " DISTINCT" : ""} ${sels.join(", ")}`);
+    if (from.length) {
+      const rels = from.map(({ as, from: from2 }) => {
+        const rel = isQuery(from2) ? `(${from2})` : `${from2}`;
+        return !as || as === from2.table ? rel : `${rel} AS "${as}"`;
+      });
+      sql.push(`FROM ${rels.join(", ")}`);
+    }
+    if (sample) {
+      const { rows, perc, method, seed } = sample;
+      const size = rows ? `${rows} ROWS` : `${perc} PERCENT`;
+      const how = method ? ` (${method}${seed != null ? `, ${seed}` : ""})` : "";
+      sql.push(`USING SAMPLE ${size}${how}`);
+    }
+    if (where.length) {
+      const clauses = where.map(String).filter((x) => x).join(" AND ");
+      if (clauses)
+        sql.push(`WHERE ${clauses}`);
+    }
+    if (groupby.length) {
+      sql.push(`GROUP BY ${groupby.join(", ")}`);
+    }
+    if (having.length) {
+      const clauses = having.map(String).filter((x) => x).join(" AND ");
+      if (clauses)
+        sql.push(`HAVING ${clauses}`);
+    }
+    if (window.length) {
+      const windows = window.map(({ as, expr: expr2 }) => `"${as}" AS (${expr2})`);
+      sql.push(`WINDOW ${windows.join(", ")}`);
+    }
+    if (qualify.length) {
+      const clauses = qualify.map(String).filter((x) => x).join(" AND ");
+      if (clauses)
+        sql.push(`QUALIFY ${clauses}`);
+    }
+    if (orderby.length) {
+      sql.push(`ORDER BY ${orderby.join(", ")}`);
+    }
+    if (Number.isFinite(limit)) {
+      sql.push(`LIMIT ${limit}`);
+    }
+    if (Number.isFinite(offset)) {
+      sql.push(`OFFSET ${offset}`);
+    }
+    return sql.join(" ");
+  }
+};
+var SetOperation = class {
+  constructor(op, queries) {
+    this.op = op;
+    this.queries = queries.map((q) => q.clone());
+    this.query = { orderby: [] };
+  }
+  clone() {
+    const q = new SetOperation(this.op, this.queries);
+    q.query = { ...this.query };
+    return q;
+  }
+  orderby(...expr2) {
+    const { query } = this;
+    if (expr2.length === 0) {
+      return query.orderby;
+    } else {
+      query.orderby = query.orderby.concat(
+        expr2.flat().filter((x) => x).map(asColumn)
+      );
+      return this;
+    }
+  }
+  limit(value) {
+    const { query } = this;
+    if (arguments.length === 0) {
+      return query.limit;
+    } else {
+      query.limit = Number.isFinite(value) ? value : void 0;
+      return this;
+    }
+  }
+  offset(value) {
+    const { query } = this;
+    if (arguments.length === 0) {
+      return query.offset;
+    } else {
+      query.offset = Number.isFinite(value) ? value : void 0;
+      return this;
+    }
+  }
+  get subqueries() {
+    const { queries, cteFor } = this;
+    if (cteFor)
+      queries.forEach((q) => q.cteFor = cteFor);
+    return queries;
+  }
+  toString() {
+    const { op, queries, query: { orderby, limit, offset } } = this;
+    const sql = [queries.join(` ${op} `)];
+    if (orderby.length) {
+      sql.push(`ORDER BY ${orderby.join(", ")}`);
+    }
+    if (Number.isFinite(limit)) {
+      sql.push(`LIMIT ${limit}`);
+    }
+    if (Number.isFinite(offset)) {
+      sql.push(`OFFSET ${offset}`);
+    }
+    return sql.join(" ");
+  }
+};
+function isQuery(value) {
+  return value instanceof Query || value instanceof SetOperation;
+}
+function unquote(s) {
+  return isDoubleQuoted(s) ? s.slice(1, -1) : s;
+}
+function isDoubleQuoted(s) {
+  return s[0] === '"' && s[s.length - 1] === '"';
+}
+
+// ../core/src/util/skip-client.js
+function skipClient(client, clause) {
+  return clause?.clients?.has(client);
+}
+
+// ../core/src/Signal.js
+function isSignal(x) {
+  return x instanceof Signal;
+}
+var Signal = class {
+  constructor(value) {
+    this._value = value;
+    this._listeners = /* @__PURE__ */ new Map();
+  }
+  get value() {
+    return this._value;
+  }
+  update(value, { force } = {}) {
+    const changed = this._value !== value;
+    if (changed)
+      this._value = value;
+    if (changed || force)
+      this.emit("value", this.value);
+    return this;
+  }
+  addEventListener(type, callback) {
+    let list = this._listeners.get(type) || [];
+    if (list.indexOf(callback) < 0) {
+      list = list.concat(callback);
+    }
+    this._listeners.set(type, list);
+  }
+  removeEventListener(type, callback) {
+    const list = this._listeners.get(type);
+    if (list?.length) {
+      this._listeners.set(type, list.filter((x) => x !== callback));
+    }
+  }
+  emit(type, event) {
+    this._listeners.get(type)?.forEach((l) => l(event));
+  }
+};
+
+// ../core/src/Selection.js
+function isSelection(x) {
+  return x instanceof Selection;
+}
+var Selection = class extends Signal {
+  static intersect() {
+    return new Selection();
+  }
+  static crossfilter() {
+    return new Selection({ cross: true });
+  }
+  static union() {
+    return new Selection({ union: true });
+  }
+  static single() {
+    return new Selection({ single: true });
+  }
+  constructor({ union, cross, single } = {}) {
+    super([]);
+    this.active = null;
+    this.union = !!union;
+    this.cross = !!cross;
+    this.single = !!single;
+  }
+  clone() {
+    const s = new Selection();
+    s.active = this.active;
+    s.union = this.union;
+    s.cross = this.cross;
+    s._value = this._value;
+    return s;
+  }
+  get value() {
+    const { clauses } = this;
+    return clauses[clauses.length - 1]?.value;
+  }
+  get clauses() {
+    return super.value;
+  }
+  activate(clause) {
+    this.emit("activate", clause);
+  }
+  update(clause) {
+    const { source, predicate } = clause;
+    this.active = clause;
+    const clauses = this.single ? [] : this.clauses.filter((c) => source !== c.source);
+    if (predicate)
+      clauses.push(clause);
+    return super.update(clauses);
+  }
+  predicate(client) {
+    const { active, clauses, cross, union } = this;
+    if (cross && skipClient(client, active))
+      return void 0;
+    const list = (cross ? clauses.filter((clause) => !skipClient(client, clause)) : clauses).map((s) => s.predicate);
+    return union && list.length > 1 ? or(list) : list;
+  }
+};
+
+// src/Menu.js
+var isObject = (v) => {
+  return v && typeof v === "object" && !Array.isArray(v);
+};
+var Menu = class extends MosaicClient {
+  constructor({
+    filterBy,
+    from,
+    column: column2,
+    label = column2,
+    options,
+    value,
+    as
+  } = {}) {
+    super(filterBy);
+    this.from = from;
+    this.column = column2;
+    this.selection = as;
+    this.element = document.createElement("div");
+    this.element.setAttribute("class", "input");
+    this.element.value = this;
+    const lab = document.createElement("label");
+    lab.innerText = label || column2;
+    this.element.appendChild(lab);
+    this.select = document.createElement("select");
+    if (options) {
+      this.data = options.map((value2) => isObject(value2) ? value2 : { value: value2 });
+      this.update();
+    }
+    value = value ?? this.selection?.value ?? this.data?.[0]?.value;
+    this.select.value = value;
+    if (this.selection?.value === void 0)
+      this.publish(value);
+    this.element.appendChild(this.select);
+    if (this.selection) {
+      this.select.addEventListener("input", () => {
+        this.publish(this.select.value || null);
+      });
+      if (!isSelection(this.selection)) {
+        this.selection.addEventListener("value", (value2) => {
+          if (value2 !== this.select.value) {
+            this.select.value = value2;
+          }
+        });
+      }
+    }
+  }
+  publish(value) {
+    const { selection, column: column2 } = this;
+    if (isSelection(selection)) {
+      selection.update({
+        source: this,
+        schema: { type: "point" },
+        value,
+        predicate: value ? eq(column2, literal(value)) : null
+      });
+    } else if (isSignal(selection)) {
+      selection.update(value);
+    }
+  }
+  fields() {
+    const { from, column: column2 } = this;
+    return from ? [column(from, column2)] : null;
+  }
+  query(filter = []) {
+    const { from, column: column2 } = this;
+    if (!from)
+      return null;
+    return Query.from(from).select({ value: column2 }).distinct().where(filter).orderby(column2);
+  }
+  queryResult(data) {
+    this.data = [{ value: "", label: "All" }, ...data];
+    return this;
+  }
+  update() {
+    const { data, select } = this;
+    select.replaceChildren();
+    for (const { value, label = value } of data) {
+      const opt = document.createElement("option");
+      opt.setAttribute("value", value);
+      opt.innerText = label;
+      this.select.appendChild(opt);
+    }
+    if (this.selection) {
+      this.select.value = this.selection?.value || "";
+    }
+    return this;
+  }
+};
+
+// src/Search.js
+var FUNCTIONS = { contains, prefix, suffix, regexp: regexp_matches };
+var _id = 0;
+var Search = class extends MosaicClient {
+  constructor({
+    filterBy,
+    from,
+    column: column2,
+    label,
+    type,
+    as
+  } = {}) {
+    super(filterBy);
+    this.id = "search_" + ++_id;
+    this.type = type;
+    this.from = from;
+    this.column = column2;
+    this.selection = as;
+    this.element = document.createElement("div");
+    this.element.setAttribute("class", "input");
+    this.element.value = this;
+    if (label) {
+      const lab = document.createElement("label");
+      lab.setAttribute("for", this.id);
+      lab.innerText = label;
+      this.element.appendChild(lab);
+    }
+    this.searchbox = document.createElement("input");
+    this.searchbox.setAttribute("id", this.id);
+    this.searchbox.setAttribute("type", "text");
+    this.searchbox.setAttribute("placeholder", "Query");
+    this.element.appendChild(this.searchbox);
+    if (this.selection) {
+      this.searchbox.addEventListener("input", () => {
+        this.publish(this.searchbox.value || null);
+      });
+      if (!isSelection(this.selection)) {
+        this.selection.addEventListener("value", (value) => {
+          if (value !== this.searchbox.value) {
+            this.searchbox.value = value;
+          }
+        });
+      }
+    }
+  }
+  publish(value) {
+    const { selection, column: column2, type } = this;
+    if (isSelection(selection)) {
+      selection.update({
+        source: this,
+        schema: { type },
+        value,
+        predicate: value ? FUNCTIONS[type](column2, literal(value)) : null
+      });
+    } else if (isSignal(selection)) {
+      selection.update(value);
+    }
+  }
+  fields() {
+    const { from, column: column2 } = this;
+    return from ? [column(from, column2)] : null;
+  }
+  query(filter = []) {
+    const { from, column: column2 } = this;
+    if (!from)
+      return null;
+    return Query.from(from).select({ list: column2 }).distinct().where(filter);
+  }
+  queryResult(data) {
+    this.data = data;
+    return this;
+  }
+  update() {
+    const list = document.createElement("datalist");
+    const id = `${this.id}_list`;
+    list.setAttribute("id", id);
+    for (const d of this.data) {
+      const opt = document.createElement("option");
+      opt.setAttribute("value", d.list);
+      list.append(opt);
+    }
+    if (this.datalist)
+      this.datalist.remove();
+    this.element.appendChild(this.datalist = list);
+    this.searchbox.setAttribute("list", id);
+    return this;
+  }
+};
+
+// src/Slider.js
+var _id2 = 0;
+var Slider = class {
+  constructor({
+    as,
+    min: min2,
+    max: max2,
+    step,
+    column: column2,
+    label = column2,
+    value = as?.value
+  } = {}) {
+    this.id = "slider_" + ++_id2;
+    this.column = column2 || "value";
+    this.selection = as;
+    this.element = document.createElement("div");
+    this.element.setAttribute("class", "input");
+    this.element.value = this;
+    if (label) {
+      const lab = document.createElement("label");
+      lab.setAttribute("for", this.id);
+      lab.innerText = label;
+      this.element.appendChild(lab);
+    }
+    this.slider = document.createElement("input");
+    this.slider.setAttribute("id", this.id);
+    this.slider.setAttribute("type", "range");
+    if (min2 != null)
+      this.slider.setAttribute("min", min2);
+    if (max2 != null)
+      this.slider.setAttribute("max", max2);
+    if (step != null)
+      this.slider.setAttribute("step", step);
+    if (value != null) {
+      this.slider.setAttribute("value", value);
+      if (this.selection?.value === void 0)
+        this.publish(value);
+    }
+    this.element.appendChild(this.slider);
+    if (this.selection) {
+      this.slider.addEventListener("input", () => {
+        this.publish(+this.slider.value);
+      });
+      if (!isSelection(this.selection)) {
+        this.selection.addEventListener("value", (value2) => {
+          if (value2 !== +this.slider.value) {
+            this.slider.value = value2;
+          }
+        });
+      }
+    }
+  }
+  publish(value) {
+    const { selection, column: column2 } = this;
+    if (isSelection(selection)) {
+      selection.update({
+        source: this,
+        schema: { type: "point" },
+        value,
+        predicate: eq(column2, literal(value))
+      });
+    } else if (isSignal(this.selection)) {
+      selection.update(value);
+    }
+  }
+};
+
+// ../../node_modules/isoformat/src/format.js
+function format(date, fallback) {
+  if (!(date instanceof Date))
+    date = /* @__PURE__ */ new Date(+date);
+  if (isNaN(date))
+    return typeof fallback === "function" ? fallback(date) : fallback;
+  const hours = date.getUTCHours();
+  const minutes = date.getUTCMinutes();
+  const seconds = date.getUTCSeconds();
+  const milliseconds = date.getUTCMilliseconds();
+  return `${formatYear(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}${hours || minutes || seconds || milliseconds ? `T${pad(hours, 2)}:${pad(minutes, 2)}${seconds || milliseconds ? `:${pad(seconds, 2)}${milliseconds ? `.${pad(milliseconds, 3)}` : ``}` : ``}Z` : ``}`;
+}
+function formatYear(year) {
+  return year < 0 ? `-${pad(-year, 6)}` : year > 9999 ? `+${pad(year, 6)}` : pad(year, 4);
+}
+function pad(value, width) {
+  return `${value}`.padStart(width, "0");
+}
+
+// src/util/format.js
+var formatLocaleAuto = localize((locale) => {
+  const formatNumber2 = formatLocaleNumber(locale);
+  return (value) => value == null ? "" : typeof value === "number" ? formatNumber2(value) : value instanceof Date ? formatDate(value) : `${value}`;
+});
+var formatLocaleNumber = localize((locale) => {
+  return (value) => value === 0 ? "0" : value.toLocaleString(locale);
+});
+var formatAuto = formatLocaleAuto();
+var formatNumber = formatLocaleNumber();
+function formatDate(date) {
+  return format(date, "Invalid Date");
+}
+function localize(f) {
+  let key = localize, value;
+  return (locale = "en") => locale === key ? value : value = f(key = locale);
+}
+
+// src/Table.js
+var _id3 = -1;
+var Table = class extends MosaicClient {
+  constructor({
+    filterBy,
+    from,
+    columns = ["*"],
+    format: format2,
+    rowBatch = 100,
+    width,
+    height = 500
+  } = {}) {
+    super(filterBy);
+    this.id = `table-${++_id3}`;
+    this.from = from;
+    this.columns = columns;
+    this.format = format2;
+    this.offset = 0;
+    this.limit = +rowBatch;
+    this.request = new Signal();
+    this.pending = false;
+    this.sortHeader = null;
+    this.sortColumn = null;
+    this.sortDesc = false;
+    this.element = document.createElement("div");
+    this.element.setAttribute("id", this.id);
+    this.element.value = this;
+    if (width) {
+      this.element.style.maxWidth = `${width}px`;
+    }
+    this.element.style.maxHeight = `${height}px`;
+    this.element.style.overflow = "auto";
+    let prevScrollTop = -1;
+    this.element.addEventListener("scroll", (evt) => {
+      const { pending, loaded } = this;
+      const { scrollHeight, scrollTop, clientHeight } = evt.target;
+      const back = scrollTop < prevScrollTop;
+      prevScrollTop = scrollTop;
+      if (back || pending || loaded)
+        return;
+      if (scrollHeight - scrollTop < 2 * clientHeight) {
+        this.pending = true;
+        this.offset += this.limit;
+        const query = this.queryInternal(this.filterBy?.predicate(this));
+        this.request.update(query);
+      }
+    });
+    this.tbl = document.createElement("table");
+    this.element.appendChild(this.tbl);
+    this.head = document.createElement("thead");
+    this.tbl.appendChild(this.head);
+    this.body = document.createElement("tbody");
+    this.tbl.appendChild(this.body);
+    this.style = document.createElement("style");
+    this.element.appendChild(this.style);
+  }
+  fields() {
+    const { from, columns } = this;
+    return columns.map((name) => column(from, name));
+  }
+  fieldStats(stats) {
+    this.stats = stats;
+    const thead = this.head;
+    thead.innerHTML = "";
+    const tr = document.createElement("tr");
+    for (const { column: column2 } of stats) {
+      const th = document.createElement("th");
+      th.addEventListener("click", (evt) => this.sort(evt, column2));
+      th.appendChild(document.createElement("span"));
+      th.appendChild(document.createTextNode(column2));
+      tr.appendChild(th);
+    }
+    thead.appendChild(tr);
+    this.formats = formatof(this.format, stats);
+    this.style.innerText = tableCSS(this.id, alignof({}, stats));
+    return this;
+  }
+  query(filter) {
+    this.offset = 0;
+    return this.queryInternal(filter);
+  }
+  queryInternal(filter = []) {
+    const { from, limit, offset, stats, sortColumn, sortDesc } = this;
+    return Query.from(from).select(stats.map((s) => s.column)).where(filter).orderby(sortColumn ? sortDesc ? desc(sortColumn) : sortColumn : []).limit(limit).offset(offset);
+  }
+  queryResult(data) {
+    if (!this.pending) {
+      this.loaded = false;
+      this.body.replaceChildren();
+    }
+    this.data = data;
+    return this;
+  }
+  update() {
+    const { body, formats, data, stats, limit } = this;
+    const nf = stats.length;
+    let count2 = 0;
+    for (const row of data) {
+      ++count2;
+      const tr = document.createElement("tr");
+      for (let i = 0; i < nf; ++i) {
+        const value = row[stats[i].column];
+        const td = document.createElement("td");
+        td.innerText = value == null ? "" : formats[i](value);
+        tr.appendChild(td);
+      }
+      body.appendChild(tr);
+    }
+    if (count2 < limit) {
+      this.loaded = true;
+    }
+    this.pending = false;
+    return this;
+  }
+  sort(event, column2) {
+    if (column2 === this.sortColumn) {
+      this.sortDesc = !this.sortDesc;
+    } else {
+      this.sortColumn = column2;
+      this.sortDesc = false;
+    }
+    const th = event.currentTarget;
+    const currentHeader = this.sortHeader;
+    if (currentHeader === th && event.metaKey) {
+      currentHeader.firstChild.textContent = "";
+      this.sortHeader = null;
+      this.sortColumn = null;
+    } else {
+      if (currentHeader)
+        currentHeader.firstChild.textContent = "";
+      this.sortHeader = th;
+      th.firstChild.textContent = this.sortDesc ? "\u25BE" : "\u25B4";
+    }
+    const query = this.query(this.filterBy?.predicate(this));
+    this.request.update(query);
+  }
+};
+function formatof(base = {}, stats, locale) {
+  return stats.map(({ column: column2, type }) => {
+    if (column2 in base) {
+      return base[column2];
+    } else {
+      switch (type) {
+        case "number":
+          return formatLocaleNumber(locale);
+        case "date":
+          return formatDate;
+        default:
+          return formatLocaleAuto(locale);
+      }
+    }
+  });
+}
+function alignof(base = {}, stats) {
+  return stats.map(({ column: column2, type }) => {
+    if (column2 in base) {
+      return base[column2];
+    } else if (type === "number") {
+      return "right";
+    } else {
+      return "left";
+    }
+  });
+}
+function tableCSS(id, align) {
+  const styles = [];
+  align.forEach((a, i) => {
+    if (a !== "left") {
+      styles.push(`#${id} tr>:nth-child(${i + 1}) {text-align:${a}}`);
+    }
+  });
+  return styles.join(" ");
+}
+export {
+  Menu,
+  Search,
+  Slider,
+  Table
+};