@helloao/tools 0.0.5 → 0.0.6-alpha

package/dist/cjs/parser/iterators.cjs

@@ -0,0 +1,204 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var iterators_exports = {};
+__export(iterators_exports, {
+  Rewindable: () => Rewindable,
+  batch: () => batch,
+  children: () => children,
+  debug: () => debug,
+  elements: () => elements,
+  isParent: () => isParent,
+  iterateAll: () => iterateAll,
+  iterateUntil: () => iterateUntil,
+  matchingParent: () => matchingParent,
+  parentChar: () => parentChar,
+  parentNote: () => parentNote,
+  rewindable: () => rewindable,
+  toAsyncIterable: () => toAsyncIterable,
+  uncompletable: () => uncompletable
+});
+module.exports = __toCommonJS(iterators_exports);
+class Rewindable {
+  buffer = [];
+  _bufferSize = 0;
+  _position = -1;
+  _iterator;
+  constructor(iterator, bufferSize = 2) {
+    this._iterator = iterator;
+    this._bufferSize = bufferSize;
+    if (this._iterator.return) {
+      this.return = (value) => {
+        return this._iterator.return(value);
+      };
+    }
+    if (this._iterator.throw) {
+      this.throw = (value) => {
+        return this._iterator.throw(value);
+      };
+    }
+  }
+  rewind(number) {
+    this._position += number;
+  }
+  [Symbol.iterator]() {
+    return this;
+  }
+  next(...args) {
+    if (this._position >= 0) {
+      let item = this.buffer[this._position];
+      this._position--;
+      return {
+        value: item,
+        done: false
+      };
+    }
+    let result = this._iterator.next(...args);
+    this.buffer.unshift(result.value);
+    if (this.buffer.length > this._bufferSize) {
+      this.buffer.splice(this._bufferSize, this.buffer.length - this._bufferSize);
+    }
+    return result;
+  }
+}
+function* debug(label, iterator) {
+  for (let value of uncompletable(iterator)) {
+    if (value instanceof Element) {
+      console.log(label, value.outerHTML);
+    } else if (value instanceof Node) {
+      console.log(label, value.textContent);
+    } else {
+      console.log(label, value);
+    }
+    yield value;
+  }
+}
+function rewindable(iterator, bufferSize = 2) {
+  return new Rewindable(iterator, bufferSize);
+}
+function* iterateNodes(node) {
+  for (let i = 0; i < node.childNodes.length; i++) {
+    yield node.childNodes[i];
+  }
+}
+function parentChar(node) {
+  return matchingParent(node, (n) => n instanceof Element && n.nodeName === "char");
+}
+function parentNote(node) {
+  return matchingParent(node, (n) => n instanceof Element && n.nodeName === "note");
+}
+function matchingParent(node, filter) {
+  let parent = node.parentNode;
+  while (parent) {
+    if (filter(parent)) {
+      return parent;
+    }
+    parent = parent.parentNode;
+  }
+  return null;
+}
+function isParent(node, parent) {
+  let parentNode = node.parentNode;
+  while (parentNode) {
+    if (parentNode === parent) {
+      return true;
+    }
+    parentNode = parentNode.parentNode;
+  }
+  return false;
+}
+function iterateAll(node) {
+  return rewindable(_iterateAll(node));
+}
+function* iterateUntil(iterator, predicate) {
+  for (let value of iterator) {
+    if (predicate(value)) {
+      return;
+    }
+    yield value;
+  }
+}
+function* _iterateAll(node) {
+  for (let child of node.childNodes) {
+    yield child;
+    yield* iterateAll(child);
+  }
+}
+function* elements(iterator) {
+  for (let node of uncompletable(iterator)) {
+    if (node instanceof Element) {
+      yield node;
+    }
+  }
+}
+function* children(iterator, parent) {
+  for (let node of uncompletable(iterator)) {
+    if (!isParent(node, parent)) {
+      iterator.rewind(1);
+      return;
+    }
+    yield node;
+  }
+}
+function* uncompletable(iterable) {
+  while (true) {
+    const { done, value } = iterable.next();
+    if (done) {
+      return;
+    }
+    yield value;
+  }
+}
+async function* toAsyncIterable(input) {
+  for (let item of input) {
+    yield item;
+  }
+}
+function* batch(input, batchSize) {
+  while (true) {
+    let batch2 = [];
+    for (let item of input) {
+      batch2.push(item);
+      if (batch2.length >= batchSize) {
+        break;
+      }
+    }
+    if (batch2.length === 0) {
+      return;
+    }
+    yield batch2;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Rewindable,
+  batch,
+  children,
+  debug,
+  elements,
+  isParent,
+  iterateAll,
+  iterateUntil,
+  matchingParent,
+  parentChar,
+  parentNote,
+  rewindable,
+  toAsyncIterable,
+  uncompletable
+});
+//# sourceMappingURL=iterators.cjs.map

package/dist/cjs/parser/iterators.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../parser/iterators.ts"],
+  "sourcesContent": ["\r\n/**\r\n * Defines an interface that represents an iterator that can be rewound.\r\n */\r\nexport interface RewindableIterator<T> extends IterableIterator<T> {\r\n    /**\r\n     * Rewinds the iterator by the specified number of elements.\r\n     * @param number The number of elements to rewind.\r\n     */\r\n    rewind(number: number): void;\r\n}\r\n\r\n/**\r\n * Defines a class that implements an iterator that can be rewound.\r\n */\r\nexport class Rewindable<T> implements RewindableIterator<T> {\r\n    buffer: T[] = [];\r\n\r\n    private _bufferSize: number = 0;\r\n    private _position: number = -1;\r\n    private _iterator: IterableIterator<T>;\r\n\r\n    constructor(iterator: IterableIterator<T>, bufferSize: number = 2) {\r\n        this._iterator = iterator;\r\n        this._bufferSize = bufferSize;\r\n\r\n        if(this._iterator.return) {\r\n            this.return = (value?: any) => {\r\n                return this._iterator.return!(value);\r\n            };\r\n        }\r\n        if(this._iterator.throw) {\r\n            this.throw = (value?: any) => {\r\n                return this._iterator.throw!(value);\r\n            };\r\n        }\r\n    }\r\n\r\n    rewind(number: number): void {\r\n        this._position += number;\r\n    }\r\n\r\n    [Symbol.iterator](): IterableIterator<T> {\r\n        return this;\r\n    }\r\n\r\n    next(...args: [] | [undefined]): IteratorResult<T, any> {\r\n        if (this._position >= 0) {\r\n            let item = this.buffer[this._position];\r\n            this._position--;\r\n            return {\r\n                value: item,\r\n                done: false\r\n            };\r\n        }\r\n\r\n        let result = this._iterator.next(...args);\r\n        this.buffer.unshift(result.value);\r\n        if (this.buffer.length > this._bufferSize) {\r\n            this.buffer.splice(this._bufferSize, this.buffer.length - this._bufferSize);\r\n        }\r\n        return result;\r\n    }\r\n\r\n    return?(value?: any): IteratorResult<T, any>;\r\n    throw?(e?: any): IteratorResult<T, any>;\r\n}\r\n\r\nexport function *debug(label: string, iterator: IterableIterator<any>) {\r\n    for (let value of uncompletable(iterator)) {\r\n        if (value instanceof Element) {\r\n            console.log(label, value.outerHTML);\r\n        } else if(value instanceof Node) {\r\n            console.log(label, value.textContent);\r\n        } else {\r\n            console.log(label, value);\r\n        }\r\n        yield value;\r\n    }\r\n}\r\n\r\n/**\r\n * Creates a new rewindable iterator from the given iterator.\r\n * @param iterator The iterator.\r\n * @param bufferSize The size of the buffer.\r\n */\r\nexport function rewindable<T>(iterator: IterableIterator<T>, bufferSize: number = 2): Rewindable<T> {\r\n    return new Rewindable(iterator, bufferSize);\r\n}\r\n\r\n\r\nfunction *iterateNodes(node: Node) {\r\n    for(let i = 0; i < node.childNodes.length; i++) {\r\n        yield node.childNodes[i];\r\n    }\r\n}\r\n\r\n/**\r\n * Gets the char element that is the parent of the given node.\r\n * @param node The node.\r\n */\r\nexport function parentChar(node: Node): Element | null {\r\n    return matchingParent(node, n => n instanceof Element && n.nodeName === 'char') as Element | null;\r\n}\r\n\r\n/**\r\n * Gets the note element that is the parent of the given node.\r\n * @param node The node.\r\n */\r\nexport function parentNote(node: Node): Element | null {\r\n    return matchingParent(node, n => n instanceof Element && n.nodeName === 'note') as Element | null;\r\n}\r\n\r\n/**\r\n * Gets the parent node that matches the given filter.\r\n * @param node The node to start the search from.\r\n * @param filter The filter that should be used.\r\n */\r\nexport function matchingParent(node: Node, filter: (node: Node) => boolean): Node | null {\r\n    let parent = node.parentNode;\r\n    while(parent) {\r\n        if (filter(parent)) {\r\n            return parent;\r\n        }\r\n        parent = parent.parentNode;\r\n    }\r\n    return null;\r\n}\r\n\r\n/**\r\n * Determines if the given node is a child of the parent node.\r\n * @param node The node to test.\r\n * @param parent The parent.\r\n * @returns \r\n */\r\nexport function isParent(node: Node, parent: Node): boolean {\r\n    let parentNode = node.parentNode;\r\n    while(parentNode) {\r\n        if (parentNode === parent) {\r\n            return true;\r\n        }\r\n        parentNode = parentNode.parentNode;\r\n    }\r\n    return false;\r\n}\r\n\r\n/**\r\n * Iterates through all of the nodes in the tree in a depth-first traversal.\r\n * @param node The node to start the traversal from. \r\n */\r\nexport function iterateAll(node: Node): RewindableIterator<Node> {\r\n    return rewindable(_iterateAll(node));\r\n}\r\n\r\nexport function *iterateUntil<T>(iterator: IterableIterator<T>, predicate: (value: T) => boolean): IterableIterator<T> {\r\n    for(let value of iterator) {\r\n        if (predicate(value)) {\r\n            return;\r\n        }\r\n        yield value;\r\n    }\r\n}\r\n\r\nfunction *_iterateAll(node: Node): IterableIterator<Node> {\r\n    for(let child of node.childNodes) {\r\n        yield child;\r\n        yield *iterateAll(child);\r\n    }\r\n}\r\n\r\n/**\r\n * Iterates only the elements in the iterator.\r\n * @param iterator The iterator that should be used.\r\n */\r\nexport function *elements(iterator: IterableIterator<Node>): IterableIterator<Element> {\r\n    for (let node of uncompletable(iterator)) {\r\n        if (node instanceof Element) {\r\n            yield node;\r\n        }\r\n    }\r\n}\r\n\r\n/**\r\n * Iterates only the children of the given node in the iterator.\r\n * @param iterator The iterator that should be used.\r\n * @param parent The parent node.\r\n */\r\nexport function *children(iterator: RewindableIterator<Node>, parent: Node): IterableIterator<Node> {\r\n    for (let node of uncompletable(iterator)) {\r\n        if (!isParent(node, parent)) {\r\n            iterator.rewind(1);\r\n            return;\r\n        }\r\n\r\n        yield node;\r\n    }\r\n}\r\n\r\n/**\r\n * Wraps the given iterable in a generator that will prevent consumers from calling return() on the iterator.\r\n * @param iterable The iterable.\r\n */\r\nexport function *uncompletable<T>(iterable: IterableIterator<T>): IterableIterator<T> {\r\n    while(true) {\r\n        const { done, value } = iterable.next();\r\n        if (done) {\r\n            return;\r\n        }\r\n        yield value;\r\n    }\r\n}\r\n\r\n/**\r\n * Converts the given iterable into an async iterable.\r\n * @param input The input iterable.\r\n */\r\nexport async function *toAsyncIterable<T>(input: Iterable<T>): AsyncIterable<T> {\r\n    for (let item of input) {\r\n        yield item;\r\n    }\r\n}\r\n\r\n/**\r\n * Batches items from the given iterator.\r\n * @param input The input iterator.\r\n * @param batchSize The size of each batch.\r\n */\r\nexport function* batch<T>(input: Iterable<T>, batchSize: number): Iterable<T[]> {\r\n    while(true) {\r\n        let batch = [] as T[];\r\n        for (let item of input) {\r\n            batch.push(item);\r\n            if (batch.length >= batchSize) {\r\n                break;\r\n            }\r\n        }\r\n\r\n        if (batch.length === 0) {\r\n            return;\r\n        }\r\n\r\n        yield batch;\r\n    }\r\n}"],
+  "mappings": "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",
+  "names": ["batch"]
+}

package/dist/cjs/parser/types.cjs

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.cjs.map

package/dist/cjs/parser/types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../parser/types.ts"],
+  "sourcesContent": ["\r\n/**\r\n * The parse tree that is gathered.\r\n */\r\nexport interface ParseTree {\r\n    type: 'root';\r\n\r\n    /**\r\n     * The ID of the parse tree.\r\n     */\r\n    id?: string;\r\n\r\n    /**\r\n     * The header that was associated with the tree.\r\n     */\r\n    header?: string;\r\n\r\n    /**\r\n     * The major title that was associated with the tree.\r\n     */\r\n    title?: string;\r\n\r\n    /**\r\n     * The list of chapters for the tree.\r\n     */\r\n    content: (Heading | Chapter)[];\r\n}\r\n\r\nexport interface Heading {\r\n    type: 'heading';\r\n    content: string[];\r\n}\r\n\r\nexport type ChapterContent = (Heading | Verse | HebrewSubtitle | LineBreak);\r\n\r\nexport type VerseContent = string | FootnoteReference | Text;\r\n\r\n/**\r\n * Defines an interface that represents a chapter.\r\n */\r\nexport interface Chapter {\r\n    type: 'chapter';\r\n    number: number;\r\n\r\n    /**\r\n     * The contents of the chapter.\r\n     */\r\n    content: ChapterContent[];\r\n\r\n    /**\r\n     * The list of footnotes for the chapter.\r\n     */\r\n    footnotes: Footnote[];\r\n}\r\n\r\n/**\r\n * Defines an interface that represents a hebrew subtitle.\r\n */\r\nexport interface HebrewSubtitle {\r\n    type: 'hebrew_subtitle';\r\n\r\n    /**\r\n     * The contents of the subtitle.\r\n     */\r\n    content: (string | Text | FootnoteReference)[];\r\n}\r\n\r\n/**\r\n * Defines an interface that represents a verse.\r\n */\r\nexport interface Verse {\r\n    type: 'verse';\r\n\r\n    number: number;\r\n\r\n    /**\r\n     * The contents of the verse.\r\n     */\r\n    content: (string | Text | InlineHeading | InlineLineBreak | FootnoteReference)[];\r\n}\r\n\r\n/**\r\n * Defines an interface that represents text that has some markup attributes applied to it.\r\n */\r\nexport interface Text {\r\n\r\n    /**\r\n     * The text that is contained.\r\n     */\r\n    text: string;\r\n\r\n    /**\r\n     * Whether the text represents a poem.\r\n     * The number indicates the level of indent.\r\n     */\r\n    poem?: number;\r\n\r\n    /**\r\n     * Whether the text contains the words of Jesus.\r\n     */\r\n    wordsOfJesus?: boolean;\r\n\r\n    /**\r\n     * Whether the text is descriptive.\r\n     * \r\n     * This is only used for \"hebrew subtitles\" that are included inside the verse markers.\r\n     */\r\n    descriptive?: boolean;\r\n}\r\n\r\n/**\r\n * Defines an interface that represents a heading that is embedded in a verse.\r\n */\r\nexport interface InlineHeading {\r\n    /**\r\n     * The text of the heading.\r\n     */\r\n    heading: string;\r\n}\r\n\r\n/**\r\n * Defines an interface that represents a line break that is embedded in a verse.\r\n */\r\nexport interface InlineLineBreak {\r\n    lineBreak: true;\r\n}\r\n\r\nexport interface FootnoteReference {\r\n    /**\r\n     * The ID of the note that is referenced.\r\n     */\r\n    noteId: number;\r\n}\r\n\r\nexport interface Footnote {\r\n    noteId: number;\r\n\r\n    /**\r\n     * The text of the footnote.\r\n     */\r\n    text: string;\r\n\r\n    /**\r\n     * The caller that should be used for the footnote.\r\n     * For footnotes, a \"caller\" is the character that is used in the text to reference to footnote.\r\n     * \r\n     * For example, in the text:\r\n     * Hello (a) World\r\n     * \r\n     * ----\r\n     * (a) This is a footnote.\r\n     * \r\n     * The \"(a)\" is the caller.\r\n     * \r\n     * If \"+\", then the caller should be autogenerated.\r\n     * If null, then the caller should be empty.\r\n     * If a string, then the caller should be that string.\r\n     */\r\n    caller: '+' | string | null;\r\n\r\n    /**\r\n     * The verse reference for the footnote.\r\n     */\r\n    reference?: {\r\n        chapter: number,\r\n        verse: number\r\n    };\r\n}\r\n\r\nexport interface LineBreak {\r\n    type: 'line_break';\r\n}"],
+  "mappings": ";;;;;;;;;;;;;;AAAA;AAAA;",
+  "names": []
+}