@dxos/echo-query 0.8.4-main.c4373fc → 0.8.4-main.c85a9c8dae

package/dist/query-env/index.js

@@ -1,387 +0,0 @@
-// ../../../common/invariant/dist/lib/browser/index.mjs
-var assertArgument = (condition, argumentName, message) => {
-  if (!condition) {
-    const error = new TypeError(`Invalid argument \`${argumentName}\`` + (message ? `: ${message}` : ""));
-    Error.captureStackTrace(error, assertArgument);
-    throw error;
-  }
-};
-
-// src/query-env/index.ts
-var OrderClass = class _OrderClass {
-  constructor(ast) {
-    this.ast = ast;
-  }
-  static variance = {};
-  static is(value) {
-    return typeof value === "object" && value !== null && "~Order" in value;
-  }
-  "~Order" = _OrderClass.variance;
-};
-var Order1;
-((Order12) => {
-  Order12.natural = new OrderClass({ kind: "natural" });
-  Order12.property = (property2, direction) => new OrderClass({
-    kind: "property",
-    property: property2,
-    direction
-  });
-})(Order1 || (Order1 = {}));
-var Order2 = Order1;
-var FilterClass = class _FilterClass {
-  constructor(ast) {
-    this.ast = ast;
-  }
-  static variance = {};
-  static is(value) {
-    return typeof value === "object" && value !== null && "~Filter" in value;
-  }
-  static fromAst(ast) {
-    return new _FilterClass(ast);
-  }
-  static everything() {
-    return new _FilterClass({
-      type: "object",
-      typename: null,
-      props: {}
-    });
-  }
-  static nothing() {
-    return new _FilterClass({
-      type: "not",
-      filter: {
-        type: "object",
-        typename: null,
-        props: {}
-      }
-    });
-  }
-  static relation() {
-    return new _FilterClass({
-      type: "object",
-      typename: null,
-      props: {}
-    });
-  }
-  static ids(...ids) {
-    if (ids.length === 0) {
-      return _FilterClass.nothing();
-    }
-    return new _FilterClass({
-      type: "object",
-      typename: null,
-      id: ids,
-      props: {}
-    });
-  }
-  static type(schema, props) {
-    if (typeof schema !== "string") {
-      throw new TypeError("expected typename as the first paramter");
-    }
-    return new _FilterClass({
-      type: "object",
-      typename: makeTypeDxn(schema),
-      ...propsFilterToAst(props ?? {})
-    });
-  }
-  static typename(typename) {
-    return new _FilterClass({
-      type: "object",
-      typename: makeTypeDxn(typename),
-      props: {}
-    });
-  }
-  static typeDXN(dxn) {
-    return new _FilterClass({
-      type: "object",
-      typename: dxn.toString(),
-      props: {}
-    });
-  }
-  static tag(tag) {
-    return new _FilterClass({
-      type: "tag",
-      tag
-    });
-  }
-  static props(props) {
-    return new _FilterClass({
-      type: "object",
-      typename: null,
-      ...propsFilterToAst(props)
-    });
-  }
-  static text(text, options) {
-    return new _FilterClass({
-      type: "text-search",
-      text,
-      searchKind: options?.type
-    });
-  }
-  static foreignKeys(schema, keys) {
-    assertArgument(typeof schema === "string", "schema");
-    assertArgument(!schema.startsWith("dxn:"), "schema");
-    return new _FilterClass({
-      type: "object",
-      typename: `dxn:type:${schema}`,
-      props: {},
-      foreignKeys: keys
-    });
-  }
-  static eq(value) {
-    if (!isRef(value) && typeof value === "object" && value !== null) {
-      throw new TypeError("Cannot use object as a value for eq filter");
-    }
-    return new _FilterClass({
-      type: "compare",
-      operator: "eq",
-      value: isRef(value) ? value.noInline().encode() : value
-    });
-  }
-  static neq(value) {
-    return new _FilterClass({
-      type: "compare",
-      operator: "neq",
-      value
-    });
-  }
-  static gt(value) {
-    return new _FilterClass({
-      type: "compare",
-      operator: "gt",
-      value
-    });
-  }
-  static gte(value) {
-    return new _FilterClass({
-      type: "compare",
-      operator: "gte",
-      value
-    });
-  }
-  static lt(value) {
-    return new _FilterClass({
-      type: "compare",
-      operator: "lt",
-      value
-    });
-  }
-  static lte(value) {
-    return new _FilterClass({
-      type: "compare",
-      operator: "lte",
-      value
-    });
-  }
-  static in(...values) {
-    return new _FilterClass({
-      type: "in",
-      values
-    });
-  }
-  static contains(value) {
-    return new _FilterClass({
-      type: "contains",
-      value
-    });
-  }
-  static between(from, to) {
-    return new _FilterClass({
-      type: "range",
-      from,
-      to
-    });
-  }
-  static not(filter) {
-    return new _FilterClass({
-      type: "not",
-      filter: filter.ast
-    });
-  }
-  static and(...filters) {
-    return new _FilterClass({
-      type: "and",
-      filters: filters.map((f) => f.ast)
-    });
-  }
-  static or(...filters) {
-    return new _FilterClass({
-      type: "or",
-      filters: filters.map((f) => f.ast)
-    });
-  }
-  "~Filter" = _FilterClass.variance;
-};
-var Filter1 = FilterClass;
-var propsFilterToAst = (predicates) => {
-  let idFilter;
-  if ("id" in predicates) {
-    assertArgument(
-      typeof predicates.id === "string" || Array.isArray(predicates.id),
-      "predicates.id",
-      "invalid id filter"
-    );
-    idFilter = typeof predicates.id === "string" ? [predicates.id] : predicates.id;
-  }
-  return {
-    id: idFilter,
-    props: Object.fromEntries(
-      Object.entries(predicates).filter(([prop, _value]) => prop !== "id").map(([prop, predicate]) => [prop, processPredicate(predicate)])
-    )
-  };
-};
-var processPredicate = (predicate) => {
-  if (FilterClass.is(predicate)) {
-    return predicate.ast;
-  }
-  if (Array.isArray(predicate)) {
-    throw new Error("Array predicates are not yet supported.");
-  }
-  if (!isRef(predicate) && typeof predicate === "object" && predicate !== null) {
-    const nestedProps = Object.fromEntries(
-      Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)])
-    );
-    return {
-      type: "object",
-      typename: null,
-      props: nestedProps
-    };
-  }
-  return FilterClass.eq(predicate).ast;
-};
-var QueryClass = class _QueryClass {
-  constructor(ast) {
-    this.ast = ast;
-  }
-  static variance = {};
-  static is(value) {
-    return typeof value === "object" && value !== null && "~Query" in value;
-  }
-  static fromAst(ast) {
-    return new _QueryClass(ast);
-  }
-  static select(filter) {
-    return new _QueryClass({
-      type: "select",
-      filter: filter.ast
-    });
-  }
-  static type(schema, predicates) {
-    return new _QueryClass({
-      type: "select",
-      filter: FilterClass.type(schema, predicates).ast
-    });
-  }
-  static all(...queries) {
-    if (queries.length === 0) {
-      throw new TypeError(
-        "Query.all combines results of multiple queries, to query all objects use Query.select(Filter.everything())"
-      );
-    }
-    return new _QueryClass({
-      type: "union",
-      queries: queries.map((q) => q.ast)
-    });
-  }
-  static without(source, exclude) {
-    return new _QueryClass({
-      type: "set-difference",
-      source: source.ast,
-      exclude: exclude.ast
-    });
-  }
-  "~Query" = _QueryClass.variance;
-  select(filter) {
-    if (FilterClass.is(filter)) {
-      return new _QueryClass({
-        type: "filter",
-        selection: this.ast,
-        filter: filter.ast
-      });
-    } else {
-      return new _QueryClass({
-        type: "filter",
-        selection: this.ast,
-        filter: FilterClass.props(filter).ast
-      });
-    }
-  }
-  reference(key) {
-    return new _QueryClass({
-      type: "reference-traversal",
-      anchor: this.ast,
-      property: key
-    });
-  }
-  referencedBy(target, key) {
-    assertArgument(typeof target === "string", "target");
-    assertArgument(!target.startsWith("dxn:"), "target");
-    return new _QueryClass({
-      type: "incoming-references",
-      anchor: this.ast,
-      property: key,
-      typename: target
-    });
-  }
-  sourceOf(relation, predicates) {
-    return new _QueryClass({
-      type: "relation",
-      anchor: this.ast,
-      direction: "outgoing",
-      filter: FilterClass.type(relation, predicates).ast
-    });
-  }
-  targetOf(relation, predicates) {
-    return new _QueryClass({
-      type: "relation",
-      anchor: this.ast,
-      direction: "incoming",
-      filter: FilterClass.type(relation, predicates).ast
-    });
-  }
-  source() {
-    return new _QueryClass({
-      type: "relation-traversal",
-      anchor: this.ast,
-      direction: "source"
-    });
-  }
-  target() {
-    return new _QueryClass({
-      type: "relation-traversal",
-      anchor: this.ast,
-      direction: "target"
-    });
-  }
-  orderBy(...order) {
-    return new _QueryClass({
-      type: "order",
-      query: this.ast,
-      order: order.map((o) => o.ast)
-    });
-  }
-  options(options) {
-    return new _QueryClass({
-      type: "options",
-      query: this.ast,
-      options
-    });
-  }
-};
-var Query1 = QueryClass;
-var RefTypeId = Symbol("@dxos/echo-query/Ref");
-var isRef = (obj) => {
-  return obj && typeof obj === "object" && RefTypeId in obj;
-};
-var makeTypeDxn = (typename) => {
-  assertArgument(typeof typename === "string", "typename");
-  assertArgument(!typename.startsWith("dxn:"), "typename");
-  return `dxn:type:${typename}`;
-};
-export {
-  Filter1 as Filter,
-  Filter1,
-  Order2 as Order,
-  Query1 as Query,
-  Query1
-};

package/dist/types/src/query-env/index.d.ts

@@ -1,8 +0,0 @@
-import type * as Echo from '@dxos/echo';
-declare const Order2: typeof Echo.Order;
-export { Order2 as Order };
-export declare const Filter1: typeof Echo.Filter;
-export { Filter1 as Filter };
-export declare const Query1: typeof Echo.Query;
-export { Query1 as Query };
-//# sourceMappingURL=index.d.ts.map

package/dist/types/src/query-env/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/query-env/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,IAAI,MAAM,YAAY,CAAC;AA0BxC,QAAA,MAAM,MAAM,EAAE,OAAO,IAAI,CAAC,KAAc,CAAC;AACzC,OAAO,EAAE,MAAM,IAAI,KAAK,EAAE,CAAC;AAkO3B,eAAO,MAAM,OAAO,EAAE,OAAO,IAAI,CAAC,MAAoB,CAAC;AACvD,OAAO,EAAE,OAAO,IAAI,MAAM,EAAE,CAAC;AA4L7B,eAAO,MAAM,MAAM,EAAE,OAAO,IAAI,CAAC,KAAkB,CAAC;AACpD,OAAO,EAAE,MAAM,IAAI,KAAK,EAAE,CAAC"}