tw5-typed 0.6.8 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tw5-typed",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "scripts": {
     "check": "tsc --noEmit && eslint src/**/*.ts",
     "docs": "docs-ts",
@@ -9,6 +9,7 @@
     "docs:generate": "npm run docs:generate:api && npm run docs:generate:copy",
     "docs:generate:api": "rimraf docs/api && typedoc --options typedoc.json",
     "docs:generate:copy": "zx scripts/copy-readme.mjs",
+    "update": "npm-check-updates -u && dprint config update",
     "prepublishOnly": "tsc --noEmit"
   },
   "description": "Types for tiddlywiki",
@@ -47,30 +48,31 @@
     ]
   },
   "dependencies": {
-    "@types/codemirror": "^5.60.15",
-    "@types/echarts": "^4.9.22",
-    "@types/node": "^20.11.24"
+    "@types/codemirror": "^5.60.17",
+    "@types/echarts": "^5.0.0",
+    "@types/node": "^24.10.1"
   },
   "devDependencies": {
-    "@docusaurus/core": "^3.1.1",
-    "@docusaurus/preset-classic": "^3.1.1",
-    "@docusaurus/types": "^3.1.1",
-    "@mdx-js/react": "^3.0.1",
+    "@docusaurus/core": "^3.9.2",
+    "@docusaurus/preset-classic": "^3.9.2",
+    "@docusaurus/types": "^3.9.2",
+    "@mdx-js/react": "^3.1.1",
     "@modern-js/eslint-config": "latest",
     "@modern-js/tsconfig": "latest",
     "docs-ts": "^0.8.0",
-    "dprint": "^0.45.0",
-    "eslint-config-tidgi": "^1.2.2",
-    "husky": "^9.0.11",
-    "lint-staged": "^15.2.2",
-    "prism-react-renderer": "^2.3.1",
-    "react": "^18.2.0",
-    "rimraf": "^5.0.5",
-    "tiddlywiki": "^5.3.3",
-    "type-fest": "^4.10.3",
-    "typedoc": "^0.25.9",
-    "typedoc-plugin-markdown": "^3.17.1",
-    "typescript": "^5.3.3",
-    "zx": "^7.2.3"
+    "dprint": "^0.50.2",
+    "eslint-config-tidgi": "^2.2.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.2.6",
+    "npm-check-updates": "^19.1.2",
+    "prism-react-renderer": "^2.4.1",
+    "react": "^19.2.0",
+    "rimraf": "^6.1.0",
+    "tiddlywiki": "^5.3.8",
+    "type-fest": "^5.2.0",
+    "typedoc": "^0.28.14",
+    "typedoc-plugin-markdown": "^4.9.0",
+    "typescript": "^5.9.3",
+    "zx": "^8.8.5"
   }
 }

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

@@ -1,7 +1,7 @@
 declare module 'tiddlywiki' {
   /**
    * # Usage
-   * 
+   *
    * ```ts
    * const yourFilter: IFilterOperator = (source,operator) => {
    * 	var results = [];
@@ -12,7 +12,7 @@ declare module 'tiddlywiki' {
    * 	return results;
    * }
    * ```
-   * 
+   *
    * # Overview
 
 Filter operators are modules (tiddlers of type `application/javascript`) with their `module-type` field set to `filteroperator`, exporting one or more functions implementing a filter.

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

@@ -96,7 +96,7 @@ declare module 'tiddlywiki' {
     */
     isAuthorized(
       authorizationType: 'readers' | 'writers',
-      username?: string | undefined,
+      username?: string,
     ): boolean;
     close(): void;
   }

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

@@ -201,10 +201,10 @@ declare module '$:/core/modules/utils/dom.js' {
    */
   export function copyToClipboard(
     text: string,
-    options?: { 
-      doNotNotify?: boolean,
-      successNotification?: string, // default is $:/language/Notifications/CopiedToClipboard/Succeeded
-      failureNotification?: string
+    options?: {
+      doNotNotify?: boolean;
+      successNotification?: string; // default is $:/language/Notifications/CopiedToClipboard/Succeeded
+      failureNotification?: string;
     },
   ): boolean;
 

package/src/modules/utils/dom/modal.d.ts

@@ -1,4 +1,4 @@
-  /// <reference path="../../widgets/index.d.ts" />
+/// <reference path="../../widgets/index.d.ts" />
 /// <reference path="../../../wiki/index.d.ts" />
 
 declare module 'tiddlywiki' {

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

@@ -18,7 +18,7 @@ declare module 'tiddlywiki' {
 }
 
 declare module '$:/core/modules/utils/filesystem.js' {
-  import type { Tiddler, Wiki, FileInfo } from 'tiddlywiki';
+  import type { FileInfo, Tiddler, Wiki } from 'tiddlywiki';
 
   /**
    * Return the subdirectories of a path

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

@@ -21,7 +21,6 @@ declare module 'tiddlywiki' {
   import * as LinkedList from '$:/core/modules/utils/linked-list.js';
   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';
@@ -30,14 +29,13 @@ declare module 'tiddlywiki' {
   import * as editionInfo from '$:/core/modules/utils/edition-info.js';
   import * as escapecss from '$:/core/modules/utils/escapecss.js';
 
-  type IUtilsModules =
+  type IUtilitiesModules =
     & Pick<typeof dom, keyof typeof dom>
     & Pick<typeof logger, keyof typeof logger>
     & Pick<typeof filesystem, keyof typeof filesystem>
     & Pick<typeof utils, keyof typeof utils>
     & 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>

package/src/utils/index.d.ts

@@ -106,7 +106,7 @@ declare module 'tiddlywiki' {
     text?: string;
   }
 
-  interface IUtilsBoot {
+  interface IUtilitiesBoot {
     Crypto: typeof Crypto;
     PasswordPrompt: typeof PasswordPrompt;
 
@@ -458,5 +458,5 @@ declare module 'tiddlywiki' {
     transliterationPairs: Record<string, string>;
   }
 
-  export type IUtils = IUtilsBoot & IUtilsModules;
+  export type IUtils = IUtilitiesBoot & IUtilsModules;
 }

package/src/wiki/index.d.ts

@@ -16,14 +16,18 @@ declare module 'tiddlywiki' {
     | 'text/html'
     | 'text/vnd.tiddlywiki'
     | 'text/plain';
-  export type ITiddlerFieldsParam = Omit<
-    Partial<ITiddlerFields>,
-    'created' | 'modified'
-  > & { created?: string; modified?: string };
-  export type ITiddlerJSONResult = Omit<
-    Partial<ITiddlerFieldsParam>,
-    'list' | 'tags'
-  > & { list?: string; tags?: string };
+  export type ITiddlerFieldsParam =
+    & Omit<
+      Partial<ITiddlerFields>,
+      'created' | 'modified'
+    >
+    & { created?: string; modified?: string };
+  export type ITiddlerJSONResult =
+    & Omit<
+      Partial<ITiddlerFieldsParam>,
+      'list' | 'tags'
+    >
+    & { list?: string; tags?: string };
   export class Wiki {
     /**
      * Wiki constructor. State is stored in private members that only a small number of privileged accessor methods have direct access. Methods added via the prototype have to use these accessors and cannot access the state data directly.
@@ -47,12 +51,104 @@ declare module 'tiddlywiki' {
     getTiddlersAsJson(filter: string, spaces?: string): string;
     /**
      * Get JSON string of tiddler. Note that this will make lists like tags/list to be string, instead of array. And result is a string, not an object.
-     * @param title 
+     * @param title
      * @returns a stringified JSON with type ITiddlerJSONResult. You will need to use `JSON.parse` on it.
      */
     getTiddlerAsJson(title: string): string;
     deleteTiddler(title: string): void;
     each(callback: (tiddler: Tiddler, title: string) => void): void;
+    /**
+     * For every tiddler invoke a callback(title,tiddler) with `this` set to the wiki object.
+     * @param options Options include sortField, excludeTag, includeSystem
+     * @param callback Function to be called for each tiddler
+     */
+    forEachTiddler(options: { sortField?: string; excludeTag?: string; includeSystem?: boolean }, callback: (title: string, tiddler: Tiddler) => void): void;
+    forEachTiddler(callback: (title: string, tiddler: Tiddler) => void): void;
+    /**
+     * Sort an array of tiddler titles by a specified field
+     * @param titles Array of titles (sorted in place)
+     * @param sortField Name of field to sort by
+     * @param isDescending True if the sort should be descending
+     * @param isCaseSensitive True if the sort should consider upper and lower case letters to be different
+     * @param isNumeric True if the sort should be numeric
+     * @param isAlphaNumeric True if the sort should be alphanumeric
+     */
+    sortTiddlers(titles: string[], sortField: string, isDescending?: boolean, isCaseSensitive?: boolean, isNumeric?: boolean, isAlphaNumeric?: boolean): void;
+    /**
+     * Return an array of tiddler titles that match a search string
+     * @param text The text string to search for
+     * @param options Search options
+     */
+    search(text: string, options?: {
+      /** An iterator function for the source tiddlers */
+      source?: (callback: (tiddler: Tiddler, title: string) => void) => void;
+      /** An array of tiddler titles to exclude from the search */
+      exclude?: string[];
+      /** If true returns tiddlers that do not contain the specified string */
+      invert?: boolean;
+      /** If true forces a case sensitive search */
+      caseSensitive?: boolean;
+      /** If specified, restricts the search to the specified field, or an array of field names */
+      field?: string | string[];
+      /** If true, forces all but regexp searches to be anchored to the start of text */
+      anchored?: boolean;
+      /** If true, the field options are inverted to specify the fields that are not to be searched */
+      excludeField?: boolean;
+      /** Searches for literal string */
+      literal?: boolean;
+      /** Same as literal except runs of whitespace are treated as a single space */
+      whitespace?: boolean;
+      /** Treats the search term as a regular expression */
+      regexp?: boolean;
+      /** Treats search string as a list of tokens, and matches if all tokens are found */
+      words?: boolean;
+      /** Treats search string as a list of tokens, and matches if at least ONE token is found */
+      some?: boolean;
+    }): string[];
+    /**
+     * Check whether the text of a tiddler matches a given value
+     * @param title Tiddler title
+     * @param targetText Text to compare with
+     * @param options Comparison options
+     */
+    checkTiddlerText(title: string, targetText: string, options?: { noTrim?: boolean; caseSensitive?: boolean }): boolean;
+    /**
+     * Return the content of a tiddler as an array containing each line
+     * @param title Title of the tiddler
+     * @param field Field name (defaults to "list")
+     * @param index Data index (key) to get, if you are getting a JSON data tiddler
+     * @returns Array of strings parsed from the field/index value
+     */
+    getTiddlerList(title: string, field?: string, index?: string): string[];
+    /**
+     * Get the value of a text reference. Text references can have any of these forms:
+     * - <tiddlertitle>
+     * - <tiddlertitle>!!<fieldname>
+     * - !!<fieldname> - specifies a field of the current tiddlers
+     * - <tiddlertitle>##<index>
+     * @param textRef The text reference string
+     * @param defaultText Default text to return if the reference is not found
+     * @param currTiddlerTitle Current tiddler title for relative references
+     */
+    getTextReference(textReference: string, defaultText?: string, currentTiddlerTitle?: string): string | undefined;
+    /**
+     * Set the value of a text reference
+     * @param textRef The text reference string
+     * @param value The value to set
+     * @param currTiddlerTitle Current tiddler title for relative references
+     */
+    setTextReference(textReference: string, value: string, currentTiddlerTitle?: string): void;
+    /**
+     * Delete a text reference
+     * @param textRef The text reference string
+     * @param currTiddlerTitle Current tiddler title for relative references
+     */
+    deleteTextReference(textReference: string, currentTiddlerTitle?: string): void;
+    /**
+     * Count the number of tiddlers in the wiki
+     * @param excludeTag Optional tag to exclude from the count
+     */
+    countTiddlers(excludeTag?: string): number;
     /**
      * Return a named global cache object. Global cache objects are cleared whenever a tiddler change.
      * You can put anything into the cache.
@@ -74,6 +170,11 @@ declare module 'tiddlywiki' {
      * clear all cache, will be called when a tiddler is changed
      */
     clearGlobalCache(): void;
+    /**
+     * Clear all caches associated with a particular tiddler, or if the title is null, clear all caches for all tiddlers
+     * @param title Tiddler title or null to clear all caches
+     */
+    clearCache(title?: string | null): void;
     /**
      * Compile filter string to be a function that execute the filter in the wiki.
      * You can pass an optional iterator that provide the input to the returned function. If no iterator is provided, filter will use first operator to get input.
@@ -89,7 +190,6 @@ declare module 'tiddlywiki' {
       widget?: Widget,
     ) => string[];
     /**
-     *
      * @param filterString
      * @param widget an optional widget node for retrieving the current tiddler etc.
      * @param source an iterator function for the source tiddlers, called source(iterator), where iterator is called as iterator(tiddler,title)
@@ -227,7 +327,7 @@ declare module 'tiddlywiki' {
     deserializeTiddlers(
       type: string,
       text: string,
-      srcFields?: ITiddlerFieldsParam,
+      sourceFields?: ITiddlerFieldsParam,
       options?: IParseOptions,
     ): ITiddlerFieldsParam[];
     /**
@@ -318,6 +418,33 @@ declare module 'tiddlywiki' {
     getShadowSource(title: string): string | null;
     getTiddlerBacklinks(targetTitle: string): string[];
     getTiddlerLinks(title: string): string[];
+    /**
+     * Return an array of tiddler titles that are directly linked within the given parse tree
+     * @param parseTreeRoot The parse tree root node
+     */
+    extractLinks(parseTreeRoot: IParseTreeNode[]): string[];
+    /**
+     * Return an array of tiddler titles that are directly transcluded within the given parse tree
+     * @param parseTreeRoot The parse tree root node
+     * @param title The tiddler being parsed (to ignore self-referential transclusions)
+     */
+    extractTranscludes(parseTreeRoot: IParseTreeNode[], title?: string): string[];
+    /**
+     * Return an array of tiddler titles that are transcluded from the specified tiddler
+     * @param title Tiddler title
+     */
+    getTiddlerTranscludes(title: string): string[];
+    /**
+     * Return an array of tiddler titles that transclude to the specified tiddler
+     * @param targetTitle Target tiddler title
+     */
+    getTiddlerBacktranscludes(targetTitle: string): string[];
+    /**
+     * Lookup a given tiddler and return a list of all the tiddlers that include it in the specified list field
+     * @param targetTitle Target tiddler title
+     * @param fieldName Field name (defaults to "list")
+     */
+    findListingsOfTiddler(targetTitle: string, fieldName?: string): string[];
     getPluginInfo(title: string): { tiddlers: Record<string, ITiddlerFields> };
     getChangeCount(title: string): number;
     /**
@@ -325,6 +452,165 @@ declare module 'tiddlywiki' {
       options.prefix must be a string
     */
     generateNewTitle(baseTitle: string, options: { prefix?: string }): string;
+    /**
+     * Get a subtiddler from a plugin or data tiddler
+     * @param title Title of the plugin or data tiddler
+     * @param subTiddlerTitle Title of the subtiddler within the bundle
+     */
+    getSubTiddler(title: string, subTiddlerTitle: string): Tiddler | null;
+    /**
+     * Return a hashmap of tiddler titles that are referenced but not defined
+     */
+    getMissingTitles(): string[];
+    /**
+     * Return an array of tiddler titles that are not linked from any other tiddler
+     */
+    getOrphanTitles(): string[];
+    /**
+     * Sorts an array of tiddler titles according to an ordered list
+     * @param array Array of tiddler titles to sort
+     * @param listTitle Title of tiddler containing the ordered list
+     */
+    sortByList(array: string[], listTitle: string): string[];
+    /**
+     * Get a hashmap by tag of arrays of tiddler titles
+     */
+    getTagMap(): Record<string, string[]>;
+    /**
+     * Find any existing draft of a specified tiddler
+     * @param targetTitle Title of the target tiddler
+     */
+    findDraft(targetTitle: string): string | undefined;
+    /**
+     * Check whether the specified draft tiddler has been modified
+     * @param title Title of the draft tiddler
+     */
+    isDraftModified(title: string): boolean;
+    /**
+     * Add a new tiddler to the story river
+     * @param title A title string or an array of title strings
+     * @param fromTitle The title of the tiddler from which the navigation originated
+     * @param storyTitle Title of story tiddler (defaults to $:/StoryList)
+     * @param options Additional options
+     * @deprecated Use story.addToStory() from the story object instead
+     */
+    addToStory(title: string | string[], fromTitle?: string, storyTitle?: string, options?: any): void;
+    /**
+     * Add a new record to the top of the history stack
+     * @param title A title string or an array of title strings
+     * @param fromPageRect Page coordinates of the origin of the navigation
+     * @param historyTitle Title of history tiddler (defaults to $:/HistoryList)
+     * @deprecated Use story.addToHistory() from the story object instead
+     */
+    addToHistory(title: string | string[], fromPageRect?: any, historyTitle?: string): void;
+    /**
+     * Generate a draft title for a given tiddler
+     * @param title Title of the tiddler to create a draft for
+     */
+    generateDraftTitle(title: string): string;
+    /**
+     * Convert a title to a URL-friendly slug
+     * @param title Title to slugify
+     * @param options Options (currently unused)
+     */
+    slugify(title: string, options?: any): string;
+    /**
+     * Invoke the available upgrader modules
+     * @param titles Array of tiddler titles to be processed
+     * @param tiddlers Hashmap by title of tiddler fields of pending import tiddlers
+     */
+    invokeUpgraders(titles: string[], tiddlers: Record<string, ITiddlerFields>): Record<string, string>;
+    /**
+     * Determine whether a plugin by title is dynamically loadable
+     * @param title Plugin title
+     */
+    doesPluginRequireReload(title: string): boolean;
+    /**
+     * Determine whether a plugin info structure is dynamically loadable
+     * @param pluginInfo Plugin info object
+     */
+    doesPluginInfoRequireReload(pluginInfo: any): boolean | null;
+    /**
+     * Execute an action string without an associated context widget
+     * @param actions Action string to execute
+     * @param event Event object
+     * @param variables Variables hashmap
+     * @param options Options including parentWidget
+     */
+    invokeActionString(actions: string, event?: any, variables?: Record<string, string>, options?: { parentWidget?: Widget }): void;
+    /**
+     * Read an array of browser File objects
+     * @param files Array of File objects
+     * @param options Options or callback function
+     */
+    readFiles(files: File[], options?: { callback?: (tiddlerFieldsArray: ITiddlerFields[]) => void } | ((tiddlerFieldsArray: ITiddlerFields[]) => void)): number;
+    /**
+     * Read a browser File object
+     * @param file File object
+     * @param options Options or callback function
+     */
+    readFile(file: File, options?: { callback?: (tiddlerFieldsArray: ITiddlerFields[]) => void; deserializer?: string } | ((tiddlerFieldsArray: ITiddlerFields[]) => void)): void;
+    /**
+     * Lower level utility to read the content of a browser File object
+     * @param file File object
+     * @param type MIME type
+     * @param isBinary Whether the file is binary
+     * @param deserializer Deserializer name
+     * @param callback Callback function
+     */
+    readFileContent(file: File, type: string, isBinary: boolean, deserializer: string | undefined, callback: (tiddlerFieldsArray: ITiddlerFields[]) => void): void;
+    /**
+     * Get substituted text with variable and filter replacements
+     * @param text Text to perform substitutions on
+     * @param widget Widget for context
+     * @param options Options including substitutions array
+     */
+    getSubstitutedText(text: string, widget: Widget, options?: { substitutions?: Array<{ name: string; value: string }> }): string;
+    /**
+     * Parse a text reference and get parser info
+     * @param title Title of tiddler
+     * @param field Field name
+     * @param index Index name
+     * @param options Options including subTiddler and defaultType
+     */
+    getTextReferenceParserInfo(
+      title: string,
+      field?: string,
+      index?: string,
+      options?: { subTiddler?: string; defaultType?: string },
+    ): { parserType: string | null; sourceText: string | null };
+    /**
+     * Parse a text reference
+     * @param title Title of tiddler
+     * @param field Field name
+     * @param index Index name
+     * @param options Parse options
+     */
+    parseTextReference(title: string, field?: string, index?: string, options?: IParseOptions): WikiParser | null;
+    /**
+     * Get the size of tiddler event queue
+     */
+    getSizeOfTiddlerEventQueue(): number;
+    /**
+     * Clear the tiddler event queue
+     */
+    clearTiddlerEventQueue(): void;
+    /**
+     * Enqueue a tiddler event (internal method)
+     * @param title Tiddler title
+     * @param isDeleted Whether the tiddler was deleted
+     * @param isShadow Whether this is a shadow tiddler change
+     */
+    enqueueTiddlerEvent(title: string, isDeleted?: boolean, isShadow?: boolean): void;
+    /**
+     * Initialize parsers (internal method)
+     * @param moduleType Module type
+     */
+    initParsers(moduleType?: string): void;
+    /**
+     * Add indexers to this wiki (internal method)
+     */
+    addIndexersToWiki(): void;
 
     removeEventListener(
       type: string,
@@ -336,11 +622,11 @@ declare module 'tiddlywiki' {
       handler: (event: unknown) => void | Promise<void>,
     ): void;
     addEventListener(
-      type: "change",
+      type: 'change',
       handler: (change: IChangedTiddlers) => void | Promise<void>,
     ): void;
     addEventListener(
-      type: "lazyLoad",
+      type: 'lazyLoad',
       handler: (title: string) => void | Promise<void>,
     ): void;
 
@@ -349,11 +635,11 @@ declare module 'tiddlywiki' {
       dataOrEvent: unknown,
     ): void;
     dispatchEvent(
-      type: "change",
+      type: 'change',
       change: IChangedTiddlers,
     ): void;
     dispatchEvent(
-      type: "lazyLoad",
+      type: 'lazyLoad',
       title: string,
     ): void;
   }