alinea/dist/core/pages/Serialize.js

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

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

// src/core/pages/Serialize.ts
import { Root } from "../Root.js";
import { Type } from "../Type.js";
import { Workspace } from "../Workspace.js";
import { entries, values } from "../util/Objects.js";
import { unreachable } from "../util/Types.js";
function seralizeLocation(config, location) {
  if (!location)
    return [];
  const isWorkspace = Workspace.isWorkspace(location);
  const isRoot = Root.isRoot(location);
  for (const [workspaceName, workspace] of entries(config.workspaces)) {
    if (workspace === location)
      return [workspaceName];
    if (isWorkspace)
      continue;
    for (const [rootName, root] of entries(workspace)) {
      if (root === location)
        return [workspaceName, rootName];
      if (isRoot)
        continue;
      const children = entries(root);
      while (children.length) {
        const [pageName, page] = children.shift();
        if (page === location)
          return [workspaceName, rootName, pageName];
        children.push(
          ...entries(page).map(
            ([name, page2]) => [pageName + "/" + name, page2]
          )
        );
      }
    }
  }
  return [];
}
function serializeSelection(targets, selection) {
  if (!selection)
    return;
  switch (selection.type) {
    case "cursor":
      return serializeCursor(targets, selection.cursor);
    case "record":
      return serializeRecord(targets, selection);
    case "expr":
      return seralizeExpr(targets, selection.expr);
    case "row":
      return serializeTarget(targets, selection.target);
  }
}
function serializeCursor(targets, cursor) {
  serializeTarget(targets, cursor.target);
  seralizeExpr(targets, cursor.where);
  if (cursor.orderBy)
    for (const order of cursor.orderBy)
      seralizeExpr(targets, order.expr);
  serializeSelection(targets, cursor.select);
}
function serializeRecord(targets, record) {
  for (const [key, value] of record.fields) {
    if (typeof key === "string") {
      serializeSelection(targets, value);
    } else {
      serializeTarget(targets, value);
    }
  }
}
function seralizeExpr(targets, expr) {
  if (!expr)
    return;
  switch (expr.type) {
    case "unop":
      return seralizeExpr(targets, expr.expr);
    case "binop":
      seralizeExpr(targets, expr.a);
      seralizeExpr(targets, expr.b);
      return;
    case "field":
      return serializeTarget(targets, expr.target);
    case "access":
      return seralizeExpr(targets, expr.expr);
    case "value":
      return;
    case "record":
      for (const field of values(expr.fields))
        seralizeExpr(targets, field);
      return;
    case "case":
      seralizeExpr(targets, expr.expr);
      for (const [condition, value] of expr.cases) {
        seralizeExpr(targets, condition);
        serializeSelection(targets, value);
      }
      if (expr.defaultCase)
        serializeSelection(targets, expr.defaultCase);
      return;
    default:
      unreachable(expr);
  }
}
function serializeTarget(targets, target) {
  if (!target?.type)
    return;
  const name = targets.get(target.type);
  const label = Type.label(target.type);
  if (!name)
    throw new Error(
      `Cannot query content type "${label}" because it is not defined in the schema`
    );
  target.name = name;
}
export {
  seralizeLocation,
  serializeSelection
};