alinea/dist/core/pages/Target.js

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

import "../../chunks/chunk-U5RRZUYZ.js";

// src/core/pages/Target.ts
import { createId } from "alinea/core/Id";
import { createExprData } from "./CreateExprData.js";
import { Cursor } from "./Cursor.js";
import { Expr, and } from "./Expr.js";
import { BinaryOp, ExprData } from "./ExprData.js";
var { create, entries } = Object;
var Target = class {
  constructor(data) {
    this.data = data;
  }
  static Data = Symbol.for("@alinea/Target.Data");
  static IsTarget = Symbol.for("@alinea/Target.IsTarget");
  cache = create(null);
  static isTarget(target) {
    return target && target[Target.IsTarget];
  }
  call(...input) {
    return new Cursor.Find({
      target: this.data,
      where: this.condition(input)
    });
  }
  condition(input) {
    if (input.length === 0)
      return void 0;
    const isConditionalRecord = input.length === 1 && !Expr.isExpr(input[0]);
    const conditions = isConditionalRecord ? entries(input[0]).map(([key, value]) => {
      const field = Expr(ExprData.Field(this.data, key));
      return Expr(
        ExprData.BinOp(
          field[Expr.Data],
          BinaryOp.Equals,
          createExprData(value)
        )
      );
    }) : input.map((ev) => Expr(createExprData(ev)));
    return and(...conditions)[Expr.Data];
  }
  get(field) {
    if (field in this.cache)
      return this.cache[field];
    return this.cache[field] = Expr(ExprData.Field(this.data, field));
  }
  static create(data) {
    const impl = new this(data);
    const name = data.name || "target";
    const call = { [name]: (...args) => impl.call(...args) }[name];
    const rowId = `@@@${createId()}`;
    return new Proxy(call, {
      ownKeys() {
        return ["prototype", rowId];
      },
      getOwnPropertyDescriptor(target, prop) {
        if (prop === rowId)
          return { enumerable: true, configurable: true };
        return Reflect.getOwnPropertyDescriptor(target, prop);
      },
      get: (_, prop) => {
        if (typeof prop === "string") {
          if (prop === rowId)
            return data;
          return impl.get(prop);
        }
        switch (prop) {
          case Target.IsTarget:
            return true;
          case Target.Data:
            return data;
        }
      }
    });
  }
};
export {
  Target
};