@notatki/core 0.0.1

package/src/note.ts

@@ -0,0 +1,189 @@
+import { type FieldNode, type NoteNode, type PropertyNode } from "@notatki/parser";
+import { type Model, type ModelField, ModelMap } from "./model.js";
+import { loc } from "./nodes.js";
+
+export class NoteList implements Iterable<Note> {
+  readonly #types: ModelMap;
+  readonly #notes: Note[];
+
+  constructor(types = new ModelMap()) {
+    this.#types = types;
+    this.#notes = [];
+  }
+
+  get types(): ModelMap {
+    return this.#types;
+  }
+
+  [Symbol.iterator](): Iterator<Note> {
+    return this.#notes[Symbol.iterator]();
+  }
+
+  get length(): number {
+    return this.#notes.length;
+  }
+
+  add(note: Note): void {
+    this.#notes.push(note);
+  }
+}
+
+export class Note implements Iterable<NoteField> {
+  readonly #type: Model;
+  #deck: string = "";
+  #tags: string = "";
+  readonly #id = new NoteField({ name: "ID", required: false });
+  readonly #fields = new Map<string, NoteField>();
+  #node: NoteNode | null = null;
+
+  constructor(type: Model) {
+    this.#type = type;
+    for (const field of type.fields) {
+      this.#fields.set(field.name.toLowerCase(), new NoteField(field));
+    }
+  }
+
+  get type(): Model {
+    return this.#type;
+  }
+
+  get deck(): string {
+    return this.#deck;
+  }
+
+  set deck(value: string | null) {
+    this.#deck = value ?? "";
+  }
+
+  get tags(): string {
+    return this.#tags;
+  }
+
+  set tags(value: string | null) {
+    this.#tags = value ?? "";
+  }
+
+  get id(): string {
+    return this.#id.value;
+  }
+
+  set id(value: string | null) {
+    this.#id.value = value;
+  }
+
+  [Symbol.iterator](): Iterator<NoteField> {
+    return this.#fields.values();
+  }
+
+  has(fieldName: string): boolean {
+    const key = fieldName.toLowerCase();
+    if (key === "id") {
+      return true;
+    }
+    return this.#fields.has(key);
+  }
+
+  get(fieldName: string): NoteField {
+    return this.#getField(fieldName);
+  }
+
+  set(fieldName: string, value: string | null): void {
+    this.#getField(fieldName).value = value;
+  }
+
+  #getField(fieldName: string): NoteField {
+    const key = fieldName.toLowerCase();
+    if (key === "id") {
+      return this.#id;
+    }
+    const field = this.#fields.get(key);
+    if (field != null) {
+      return field;
+    }
+    throw new Error(`Unknown field: "${fieldName}"`);
+  }
+
+  get first(): NoteField {
+    const [first] = this.#fields.values();
+    if (first != null) {
+      return first;
+    }
+    throw new Error("No fields");
+  }
+
+  get node(): NoteNode | null {
+    return this.#node;
+  }
+
+  set node(value: NoteNode | null) {
+    this.#node = value;
+  }
+
+  toNode(): NoteNode {
+    const properties: PropertyNode[] = [];
+    properties.push({ name: { text: "type", loc }, value: { text: this.#type.name, loc }, loc });
+    properties.push({ name: { text: "deck", loc }, value: { text: this.#deck, loc }, loc });
+    properties.push({ name: { text: "tags", loc }, value: { text: this.#tags, loc }, loc });
+    const fields: FieldNode[] = [];
+    if (this.#id.value) {
+      fields.push(this.#id.toNode());
+    }
+    for (const field of this.#fields.values()) {
+      if (field.value) {
+        fields.push(field.toNode());
+      }
+    }
+    return {
+      properties,
+      fields,
+      end: { text: "~~~", loc },
+      loc,
+    };
+  }
+
+  static isIdField(fieldName: string): boolean {
+    return fieldName.toLowerCase() === "id";
+  }
+}
+
+export class NoteField {
+  readonly #type: ModelField;
+  #value: string = "";
+  #node: FieldNode | null = null;
+
+  constructor(type: ModelField) {
+    this.#type = type;
+  }
+
+  get name(): string {
+    return this.#type.name;
+  }
+
+  get required(): boolean {
+    return this.#type.required ?? false;
+  }
+
+  get value(): string {
+    return this.#value;
+  }
+
+  set value(value: string | null) {
+    this.#value = value ?? "";
+  }
+
+  get node(): FieldNode | null {
+    return this.#node;
+  }
+
+  set node(value: FieldNode | null) {
+    this.#node = value;
+  }
+
+  toNode(): FieldNode {
+    return {
+      name: { text: this.#type.name.toLowerCase(), loc },
+      value: { text: this.#value, loc },
+      loc,
+    };
+  }
+}

package/src/output.ts

@@ -0,0 +1,27 @@
+export class Output {
+  readonly #lines: string[] = [];
+  #separate = false;
+  #text: string | null = null;
+
+  separate(): void {
+    if (this.#lines.length > 0) {
+      this.#separate = true;
+      this.#text = null;
+    }
+  }
+
+  print(line: string): void {
+    if (line.length > 0) {
+      if (this.#separate) {
+        this.#lines.push("");
+        this.#separate = false;
+      }
+      this.#lines.push(line);
+      this.#text = null;
+    }
+  }
+
+  toString(): string {
+    return (this.#text ??= this.#lines.join("\n") + "\n");
+  }
+}

package/src/print-model-nodes.ts

@@ -0,0 +1,39 @@
+import { type ModelNode } from "@notatki/parser";
+import { Output } from "./output.js";
+
+export function printModelNodes(nodes: Iterable<ModelNode>): string {
+  const out = new Output();
+  for (const { name, id, cloze, fields, cards, styling } of nodes) {
+    out.separate();
+    out.print(`model ${name.text}`);
+    out.separate();
+    out.print(`id ${id.value}`);
+    if (cloze != null) {
+      out.separate();
+      out.print("cloze");
+    }
+    out.separate();
+    for (const { name, required } of fields) {
+      out.print(`field ${name.text}${required ? "" : "?"}`);
+    }
+    out.separate();
+    for (const { name, front, back } of cards) {
+      out.print(`card ${name.text}`);
+      out.separate();
+      out.print("front");
+      out.print(front.text);
+      out.print("~~~");
+      out.separate();
+      out.print("back");
+      out.print(back.text);
+      out.print("~~~");
+      out.separate();
+    }
+    if (styling != null) {
+      out.print("styling");
+      out.print(styling.text);
+      out.print("~~~");
+    }
+  }
+  return String(out);
+}

package/src/print-note-nodes.ts

@@ -0,0 +1,31 @@
+import { type NoteNode } from "@notatki/parser";
+import { Output } from "./output.js";
+
+export function printNoteNodes(nodes: Iterable<NoteNode>): string {
+  const out = new Output();
+  for (const { properties, fields, end } of nodes) {
+    out.separate();
+    for (const { name, value } of properties) {
+      if (value.text) {
+        out.print(`!${name.text}: ${value.text}`);
+      } else {
+        out.print(`!${name.text}:`);
+      }
+    }
+    out.separate();
+    for (const { name, value } of fields) {
+      if (value.text) {
+        if (value.text.includes("\n")) {
+          out.print(`!${name.text}:`);
+          out.print(value.text);
+        } else {
+          out.print(`!${name.text}: ${value.text}`);
+        }
+      } else {
+        out.print(`!${name.text}:`);
+      }
+    }
+    out.print(end.text);
+  }
+  return String(out);
+}

package/src/reformat-model-nodes.ts

@@ -0,0 +1,5 @@
+import { type ModelNode } from "@notatki/parser";
+
+export function reformatModelNodes(nodes: Iterable<ModelNode>): ModelNode[] {
+  return [...nodes];
+}

package/src/reformat-note-nodes.ts

@@ -0,0 +1,34 @@
+import { type FieldNode, type NoteNode, type PropertyNode, type Token } from "@notatki/parser";
+import { loc } from "./nodes.js";
+
+export function reformatNoteNodes(nodes: Iterable<NoteNode>): NoteNode[] {
+  return [...nodes].map(mapNoteNode);
+}
+
+function mapNoteNode(node: NoteNode): NoteNode {
+  return {
+    properties: node.properties.map(mapPropertyNode),
+    fields: node.fields.map(mapFieldNode),
+    end: { text: "~~~", loc },
+    loc,
+  };
+}
+
+function mapPropertyNode({ name, value }: PropertyNode): PropertyNode {
+  return {
+    name: nameOf(name),
+    value: { text: value.text, loc },
+    loc,
+  };
+}
+function mapFieldNode({ name, value }: FieldNode): FieldNode {
+  return {
+    name: nameOf(name),
+    value: { text: value.text, loc },
+    loc,
+  };
+}
+
+function nameOf({ text }: Token): Token {
+  return { text: text.toLowerCase(), loc };
+}