alinea/dist/core/pages/Cursor.js

[](https://npmjs.org/package/alinea) [](https://packagephobia.com/result?p=alinea)

import {
  array,
  boolean,
  enums,
  number,
  object,
  string
} from "../../chunks/chunk-7LBNER34.js";
import "../../chunks/chunk-U5RRZUYZ.js";

// src/core/pages/Cursor.ts
import { entries } from "../util/Objects.js";
import { createExprData } from "./CreateExprData.js";
import { createSelection } from "./CreateSelection.js";
import { Expr, and } from "./Expr.js";
import { BinaryOp, ExprData } from "./ExprData.js";
import { Selection } from "./Selection.js";
import { TargetData } from "./TargetData.js";
var OrderDirection = /* @__PURE__ */ ((OrderDirection2) => {
  OrderDirection2["Asc"] = "Asc";
  OrderDirection2["Desc"] = "Desc";
  return OrderDirection2;
})(OrderDirection || {});
var OrderBy = object(
  class {
    expr = ExprData.adt;
    order = enums(OrderDirection);
  }
);
var CursorData = object(
  class {
    target = TargetData.optional;
    where = ExprData.adt.optional;
    searchTerms = array(string).optional;
    skip = number.optional;
    take = number.optional;
    orderBy = array(OrderBy).optional;
    groupBy = array(ExprData.adt).optional;
    select = Selection.adt.optional;
    first = boolean.optional;
    source = CursorSource.optional;
  }
);
var SourceType = /* @__PURE__ */ ((SourceType2) => {
  SourceType2["Children"] = "Children";
  SourceType2["Siblings"] = "Siblings";
  SourceType2["Translations"] = "Translations";
  SourceType2["Parents"] = "Parents";
  SourceType2["Parent"] = "Parent";
  SourceType2["Next"] = "Next";
  SourceType2["Previous"] = "Previous";
  return SourceType2;
})(SourceType || {});
var CursorSource = object(
  class {
    type = enums(SourceType);
    // id = string
    depth = number.optional;
  }
);
var Cursor = class _Cursor {
  constructor(data) {
    this[_Cursor.Data] = data;
  }
  with(data) {
    return { ...this[_Cursor.Data], ...data };
  }
  static isCursor(input) {
    return Boolean(input && input[_Cursor.Data]);
  }
  toJSON() {
    return this[_Cursor.Data];
  }
};
((Cursor2) => {
  Cursor2.Data = Symbol.for("@alinea/Cursor.Data");
  class Find extends Cursor2 {
    where(...where) {
      const current = this[Cursor2.Data].where;
      return new Find(
        this.with({
          where: and(current ? Expr(current) : true, ...where)[Expr.Data]
        })
      );
    }
    search(...searchTerms) {
      if (searchTerms.length === 0)
        return this;
      return new Find(this.with({ searchTerms }));
    }
    get(select) {
      const query = this.with({ first: true });
      if (select)
        query.select = createSelection(select);
      return new Get(query);
    }
    count() {
      return new Cursor2(
        this.with({ first: true, select: Selection.Count() })
      );
    }
    first() {
      return new Get(this.with({ first: true }));
    }
    maybeFirst() {
      return new Get(this.with({ first: true }));
    }
    select(select) {
      return new Find(
        this.with({ select: createSelection(select) })
      );
    }
    groupBy(...groupBy) {
      return new Find(this.with({ groupBy: groupBy.map(createExprData) }));
    }
    orderBy(...orderBy) {
      return new Find(this.with({ orderBy }));
    }
    skip(skip) {
      return new Find(this.with({ skip }));
    }
    take(take) {
      return new Find(this.with({ take }));
    }
  }
  Cursor2.Find = Find;
  class Partial extends Find {
    constructor(type, partial) {
      super({
        target: { type },
        where: Partial.condition(type, partial)
      });
      this.type = type;
      this.partial = partial;
    }
    static condition(type, input) {
      const conditions = entries(input || {}).map(([key, value]) => {
        const field = Expr(ExprData.Field({ type }, key));
        return Expr(
          ExprData.BinOp(
            field[Expr.Data],
            BinaryOp.Equals,
            createExprData(value)
          )
        );
      });
      return and(...conditions)[Expr.Data];
    }
  }
  Cursor2.Partial = Partial;
  class Get extends Cursor2 {
    where(...where) {
      const current = this[Cursor2.Data].where;
      return new Get(
        this.with({
          where: and(current ? Expr(current) : true, ...where)[Expr.Data]
        })
      );
    }
    search(...searchTerms) {
      return new Get(this.with({ searchTerms }));
    }
    select(select) {
      return new Get(
        this.with({ select: createSelection(select) })
      );
    }
  }
  Cursor2.Get = Get;
})(Cursor || (Cursor = {}));
export {
  Cursor,
  CursorData,
  CursorSource,
  OrderBy,
  OrderDirection,
  SourceType
};