tw5-typed 0.5.4 → 0.5.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tw5-typed",
-  "version": "0.5.4",
+  "version": "0.5.5",
   "scripts": {
     "check": "tsc --noEmit && eslint src/**/*.ts",
     "docs": "docs-ts",

package/src/modules/parsers/index.d.ts

@@ -154,4 +154,25 @@ declare module 'tiddlywiki' {
     | ICustomParseTreeNode
     | IMacroParseTreeNode
     | IParseTreeAttribute;
+
+  export interface FilterParseTreeNode {
+    operators: FilterOperatorParseTreeNode[];
+    prefix: string;
+  }
+  export interface FilterOperatorParseTreeNode {
+    operands: FilterOperandParseTreeNode[];
+    operator: string;
+    suffix: string;
+    suffixes: string[][];
+  }
+  export interface FilterOperandParseTreeNode {
+    text: string;
+  }
+
+  export interface Wiki {
+    /**
+     * Parse a filter string
+     */
+    parseFilter(filter: string): FilterParseTreeNode[];
+  }
 }

package/src/modules/utils/index.d.ts

@@ -22,6 +22,7 @@ declare module 'tiddlywiki' {
   import * as performance from '$:/core/modules/utils/performance.js';
   // import the class directly, to fix: Property 'log' does not exist on type 'typeof Logger'.ts(2339)
   import * as parsetree from '$:/core/modules/utils/parsetree.js';
+  import * as parseutils from '$:/core/modules/utils/parseutils.js';
   import * as pluginMaker from '$:/core/modules/utils/pluginmaker.js';
   import * as transliterate from '$:/core/modules/utils/transliterate.js';
   import * as crypto from '$:/core/modules/utils/crypto.js';
@@ -37,6 +38,7 @@ declare module 'tiddlywiki' {
     & Pick<typeof LinkedList, keyof typeof LinkedList>
     & Pick<typeof performance, keyof typeof performance>
     & Pick<typeof parsetree, keyof typeof parsetree>
+    & Pick<typeof parseutils, keyof typeof parseutils>
     & Pick<typeof pluginMaker, keyof typeof pluginMaker>
     & Pick<typeof transliterate, keyof typeof transliterate>
     & Pick<typeof crypto, keyof typeof crypto>

package/src/modules/utils/parseutils.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Utility functions concerned with parsing text into tokens.
+ * Most functions have the following pattern:
+ * - The parameters are:
+ *   - `source`: the source string being parsed
+ *   - `pos`: the current parse position within the string
+ *   - Any further parameters are used to identify the token that is being parsed
+ * - The return value is:
+ *   - null if the token was not found at the specified position
+ *   - an object representing the token with the following standard fields:
+ *     - `type`: string indicating the type of the token
+ *     - `start`: start position of the token in the source string
+ *     - `end`: end position of the token in the source string
+ *     - Any further fields required to describe the token
+ * The exception is `skipWhiteSpace`, which just returns the position after the whitespace.
+ */
+declare module '$:/core/modules/utils/parseutils.js' {
+  /**
+   * Look for a whitespace token. Returns null if not found, otherwise returns an object.
+   */
+  export function parseWhiteSpace(source: string, pos: number): { end: number; start: number; type: 'whitespace' } | null;
+
+  /**
+   * Convenience wrapper for parseWhiteSpace. Returns the position after the whitespace.
+   */
+  export function skipWhiteSpace(source: string, pos: number): number;
+
+  /**
+   * Look for a given string token. Returns null if not found, otherwise returns an object.
+   */
+  export function parseTokenString(source: string, pos: number, token: string): { end: number; start: number; type: 'token'; value: string } | null;
+
+  /**
+   * Look for a token matching a regex. Returns null if not found, otherwise returns an object.
+   */
+  export function parseTokenRegExp(source: string, pos: number, reToken: RegExp): { end: number; match: RegExpExecArray; start: number; type: 'regexp' } | null;
+
+  /**
+   * Look for a string literal. Returns null if not found, otherwise returns an object.
+   */
+  export function parseStringLiteral(source: string, pos: number): { end: number; start: number; type: 'string'; value: string } | null;
+
+  /**
+   * Returns an array of {name:} with an optional "default" property. Options include `requireParenthesis`.
+   */
+  export function parseParameterDefinition(parameterString: string, options?: { requireParenthesis?: boolean }): Array<{ default?: string; name: string }>;
+
+  /**
+   * Process parameters for macro invocation.
+   */
+  export function parseMacroParameters(node: any, source: string, pos: number): any;
+
+  /**
+   * Look for a macro invocation parameter. Returns null if not found.
+   */
+  export function parseMacroParameter(source: string, pos: number): { end: number; name?: string; start: number; type: 'macro-parameter'; value: string } | null;
+
+  /**
+   * Look for a macro invocation. Returns null if not found.
+   */
+  export function parseMacroInvocation(source: string, pos: number): { end: number; name: string; params: any[]; start: number; type: 'macrocall' } | null;
+
+  /**
+   * Look for a macro invocation as transclusion. Returns null if not found.
+   */
+  export function parseMacroInvocationAsTransclusion(source: string, pos: number): { attributes: any; end: number; start: number; type: 'transclude' } | null;
+
+  export interface FilterVariableParseTreeNode {
+    name: string;
+    params: FilterVariableParameterParseTreeNode[];
+  }
+  export interface FilterVariableParameterParseTreeNode {
+    end: number;
+    start: number;
+    type: string;
+    value: string;
+  }
+  /**
+   * Parse filter variable parameters.
+   */
+  export function parseFilterVariable(source: string): FilterVariableParseTreeNode;
+
+  /**
+   * Look for an HTML attribute definition. Returns null if not found, otherwise returns an object.
+   */
+  export function parseAttribute(
+    source: string,
+    pos: number,
+  ): { end: number; filter?: string; name: string; start: number; textReference?: string; type: 'attribute'; value?: string } | null;
+}