@dxos/echo-query 0.8.4-main.ae835ea → 0.8.4-main.bc674ce

package/dist/query-lite/index.js

@@ -1,387 +1,367 @@
-// ../../../common/invariant/dist/lib/browser/index.mjs
+//#region ../../../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;
-  }
+	if (!condition) {
+		const error = /* @__PURE__ */ new TypeError(`Invalid argument \`${argumentName}\`` + (message ? `: ${message}` : ""));
+		Error.captureStackTrace(error, assertArgument);
+		throw error;
+	}
 };
 
-// src/query-lite/query-lite.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;
+//#endregion
+//#region src/query-lite/query-lite.ts
+var OrderClass = class OrderClass {
+	static variance = {};
+	static is(value) {
+		return typeof value === "object" && value !== null && "~Order" in value;
+	}
+	constructor(ast) {
+		this.ast = ast;
+	}
+	"~Order" = OrderClass.variance;
 };
-var Order1;
-((Order12) => {
-  Order12.natural = new OrderClass({ kind: "natural" });
-  Order12.property = (property2, direction) => new OrderClass({
-    kind: "property",
-    property: property2,
-    direction
-  });
+let Order1;
+(function(_Order) {
+	_Order.natural = new OrderClass({ kind: "natural" });
+	_Order.property = (property, direction) => new OrderClass({
+		kind: "property",
+		property,
+		direction
+	});
+	_Order.rank = (direction = "desc") => new OrderClass({
+		kind: "rank",
+		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;
+const Order2 = Order1;
+var FilterClass = class FilterClass {
+	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 id(...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)
+		});
+	}
+	constructor(ast) {
+		this.ast = 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)])
-    )
-  };
+const Filter1 = FilterClass;
+const 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;
+const 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) return {
+		type: "object",
+		typename: null,
+		props: Object.fromEntries(Object.entries(predicate).map(([key, value]) => [key, processPredicate(value)]))
+	};
+	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 QueryClass = class QueryClass {
+	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
+		});
+	}
+	constructor(ast) {
+		this.ast = 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) {
+		const typename = target !== void 0 ? (assertArgument(typeof target === "string", "target"), assertArgument(!target.startsWith("dxn:"), "target"), target) : null;
+		return new QueryClass({
+			type: "incoming-references",
+			anchor: this.ast,
+			property: key ?? null,
+			typename
+		});
+	}
+	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)
+		});
+	}
+	limit(limit) {
+		return new QueryClass({
+			type: "limit",
+			query: this.ast,
+			limit
+		});
+	}
+	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;
+const Query1 = QueryClass;
+const RefTypeId = Symbol("@dxos/echo-query/Ref");
+const 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
+const makeTypeDxn = (typename) => {
+	assertArgument(typeof typename === "string", "typename");
+	assertArgument(!typename.startsWith("dxn:"), "typename");
+	return `dxn:type:${typename}`;
 };
+
+//#endregion
+export { Filter1 as Filter, Filter1, Order2 as Order, Query1 as Query, Query1 };
+//# sourceMappingURL=index.js.map