tw5-typed 0.2.14 → 0.2.16

package/package.json

@@ -2,7 +2,7 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "url": "https://github.com/tiddly-gittly/tw5-typed",
   "homepage": "https://github.com/tiddly-gittly/tw5-typed",
   "bugs": {
@@ -17,31 +17,28 @@
     "src/"
   ],
   "scripts": {
-    "prepublishOnly": "npx tsc --noEmit"
+    "check": "tsc --noEmit && eslint src/**/*.ts"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged"
+    }
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": [
+      "node --max_old_space_size=8192 ./node_modules/eslint/bin/eslint.js --fix --color --cache --quiet"
+    ],
+    "*.{js,jsx,mjs,mjsx,cjs,cjsx}": [
+      "node --max_old_space_size=8192 ./node_modules/eslint/bin/eslint.js --fix --color --cache --quiet"
+    ]
   },
   "devDependencies": {
-    "@types/node": "^18.11.12",
-    "@typescript-eslint/eslint-plugin": "5.46.0",
-    "@typescript-eslint/parser": "5.46.0",
-    "eslint": "8.29.0",
-    "eslint-config-prettier": "8.5.0",
-    "eslint-config-standard": "17.0.0",
-    "eslint-config-standard-with-typescript": "23.0.0",
-    "eslint-import-resolver-alias": "1.1.2",
-    "eslint-import-resolver-typescript": "3.5.2",
-    "eslint-plugin-html": "7.1.0",
-    "eslint-plugin-import": "2.26.0",
-    "eslint-plugin-n": "15.6.0",
-    "eslint-plugin-node": "11.1.0",
-    "eslint-plugin-prettier": "4.2.1",
-    "eslint-plugin-promise": "6.1.1",
-    "eslint-plugin-react": "7.31.11",
-    "eslint-plugin-react-hooks": "4.6.0",
-    "eslint-plugin-security": "1.5.0",
-    "eslint-plugin-security-node": "1.1.1",
-    "eslint-plugin-typescript-sort-keys": "2.1.0",
-    "eslint-plugin-unicorn": "45.0.1",
-    "prettier": "2.8.1",
-    "typescript": "4.9.4"
+    "@modern-js/eslint-config": "latest",
+    "@modern-js/tsconfig": "latest",
+    "@types/node": "^18.11.9",
+    "husky": "^8.0.2",
+    "lint-staged": "^13.1.0",
+    "rimraf": "^3.0.2",
+    "typescript": "^4.9.4"
   }
 }

package/src/PasswordPrompt.d.ts

@@ -15,11 +15,12 @@ declare module 'tiddlywiki' {
   ) => boolean;
 
   export class PasswordPrompt {
-    /** Creates a PasswordPrompt object */
-    constructor();
     /** Store of pending password prompts */
     passwordPrompts: PasswordPromptInfo[];
+
     promptWrapper: TWDOMElement;
+    /** Creates a PasswordPrompt object */
+    constructor();
     /** Hides or shows the wrapper depending on whether there are any outstanding prompts */
     setWrapperDisplay(): void;
     /**

package/src/Tiddler.d.ts

@@ -1,13 +1,15 @@
 declare module 'tiddlywiki' {
   export class Tiddler {
+    static fieldModules: Record<string, IModuleInfo>;
+
+    readonly cache: ITiddlerCache;
+
+    readonly fields: ITiddlerFields;
     /**
      *
      * @param tiddlers multiple tiddler fields or instances, will merge them to create a new one
      */
     constructor(...tiddlers: Array<Record<string, unknown> | Tiddler>);
-    readonly cache: ITiddlerCache;
-    readonly fields: ITiddlerFields;
-    static fieldModules: Record<string, IModuleInfo>;
     hasField(field: string): boolean;
     isEqual(tiddler: Tiddler, excludeFields: string[]): boolean;
   }

package/src/Wiki.d.ts

@@ -5,14 +5,22 @@ declare module 'tiddlywiki' {
     document: typeof document | IFakeDocument;
   }
 
-  export type OutputMimeTypes = 'text/html' | 'text/plain-formatted' | 'text/plain';
-  export type TextMimeTypes = 'text/html' | 'text/vnd.tiddlywiki' | 'text/plain';
+  export type OutputMimeTypes =
+    | 'text/html'
+    | 'text/plain-formatted'
+    | 'text/plain';
+  export type TextMimeTypes =
+    | 'text/html'
+    | 'text/vnd.tiddlywiki'
+    | 'text/plain';
   export interface IRenderOptions {
     parentWidget?: Widget;
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     variables?: Record<string, any>;
   }
-  export type ITiddlerFieldsParam = Omit<Partial<ITiddlerFields>, 'created' | 'modified'> & { created?: string; modified?: string };
+  export type ITiddlerFieldsParam = Omit<
+    Partial<ITiddlerFields>,
+    'created' | 'modified'
+  > & { created?: string; modified?: 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.
@@ -22,11 +30,13 @@ declare module 'tiddlywiki' {
      */
     constructor(options: { enableIndexers: unknown[] });
     addIndexer(indexer: unknown, name: string): void;
-    getTiddler: <T extends Tiddler>(title: string) => T | undefined;
+    getTiddler<T extends Tiddler>(title: string): T | void;
     /**
      * Get full list of tiddler titles in the wiki
      */
     getTiddlers(): string[];
+    deleteTiddler(title: string): void;
+    each(callback: (tiddler: Tiddler, title: string) => void): void;
     /**
      * Return a named global cache object. Global cache objects are cleared whenever a tiddler change.
      * You can put anything into the cache.
@@ -39,7 +49,11 @@ declare module 'tiddlywiki' {
      * @param cacheName key of the cache
      * @param initializer when cache miss, this will be called to get initial value
      */
-    getCacheForTiddler<T>(title: string, cacheName: string, initializer: () => T): T;
+    getCacheForTiddler<T>(
+      title: string,
+      cacheName: string,
+      initializer: () => T,
+    ): T;
     /**
      * clear all cache, will be called when a tiddler is changed
      */
@@ -47,33 +61,48 @@ declare module 'tiddlywiki' {
     /**
      * 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.
-     * 
+     *
      * @returns a function with the signature fn(source,widget) where:
         source: an iterator function for the source tiddlers, called source(iterator), where iterator is called as iterator(tiddler,title)
         widget: an optional widget node for retrieving the current tiddler etc.
      */
-    compileFilter(filterString: string): (source?: SourceIterator, widget?: Widget) => string[];
+    compileFilter(
+      filterString: string,
+    ): (source?: SourceIterator, 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)
      */
-    filterTiddlers(filterString: string, widget?: Widget, source?: SourceIterator): string[];
+    filterTiddlers(
+      filterString: string,
+      widget?: Widget,
+      source?: SourceIterator,
+    ): string[];
     /**
      * Set JSON tiddler, Object in data field will be JSON.stringify and put into the text.
      * This will make tiddler to be JSON data tiddler `"type":"application/json"`, so if you just want to modify existed tiddler's data, use `addTiddler` instead.
      */
-    setTiddlerData: (title: string, data?: object, fields?: ITiddlerFieldsParam, options?: any) => void;
+    setTiddlerData(
+      title: string,
+      data?: object,
+      fields?: ITiddlerFieldsParam,
+      options?: any,
+    ): void;
     /**
      * Create or update tiddler.
      * Update existed tiddler based on the title field.
      */
-    addTiddler: (tiddler: Tiddler | Partial<ITiddlerFieldsParam> | Partial<ITiddlerFields>) => void;
+    addTiddler(
+      tiddler: Tiddler | Partial<ITiddlerFieldsParam> | Partial<ITiddlerFields>,
+    ): void;
     /**
      * Call `addTiddler` for each iton of the list, but should passing `tiddler.fields`, directly passing tiddler object may failed to add in some cases.
      */
-    addTiddlers: (tiddler: Array<Partial<ITiddlerFieldsParam>| Partial<ITiddlerFields>>) => void;
+    addTiddlers(
+      tiddler: Array<Partial<ITiddlerFieldsParam> | Partial<ITiddlerFields>>,
+    ): void;
     /**
      * Get tiddler's text field, with an optional default text.
      * If have _is_skinny field, will just return null (this is a rare case, so not put in the return type for now).
@@ -96,11 +125,13 @@ declare module 'tiddlywiki' {
 
       Alternative, uncached version of getTiddlerDataCached(). The return value can be mutated freely and reused
     */
-    getTiddlerData<D extends Record<any, unknown> | any[] | undefined>(titleOrTiddler: string, fallbackData?: D): D;
-    getTiddlerData<D extends Record<any, unknown> | any[] | undefined>(titleOrTiddler: Tiddler, fallbackData?: D): D;
+    getTiddlerData<D extends Record<any, unknown> | any[] | undefined>(
+      titleOrTiddler: string | Tiddler,
+      fallbackData?: D,
+    ): D;
     /**
      * D is any JSON, like JSON object or JSON array
-     * 
+     *
      * Get the content of a tiddler as a JavaScript object. How this is done depends on the type of the tiddler:
 
       application/json: the tiddler JSON is parsed into an object
@@ -113,8 +144,10 @@ declare module 'tiddlywiki' {
 
       Note that the same value is returned for repeated calls for the same tiddler data. The value is frozen to prevent modification; otherwise modifications would be visible to all callers
     */
-    getTiddlerDataCached<D>(titleOrTiddler: string, fallbackData?: D): D;
-    getTiddlerDataCached<D>(titleOrTiddler: Tiddler, fallbackData?: D): D;
+    getTiddlerDataCached<D>(
+      titleOrTiddler: string | Tiddler,
+      fallbackData?: D,
+    ): D;
     /**
      * Set tiddler text of any field.
      *
@@ -124,7 +157,13 @@ declare module 'tiddlywiki' {
      * @param {string} value text content to set
      * @param {object} options options, see tiddlywiki dev doc for details
      */
-    setText: (title: string, field?: string, index?: string | undefined, value?: string, options?: { suppressTimestamp?: boolean }) => void;
+    setText(
+      title: string,
+      field?: string,
+      index?: string,
+      value?: string,
+      options?: { suppressTimestamp?: boolean },
+    ): void;
     /**
       Parse a tiddler according to its MIME type
     */
@@ -149,7 +188,11 @@ declare module 'tiddlywiki' {
       variables: hashmap of variables to set
       parentWidget: optional parent widget for the root node
       */
-    renderTiddler(outputType: OutputMimeTypes, title: string, options?: IRenderOptions): string;
+    renderTiddler(
+      outputType: OutputMimeTypes,
+      title: string,
+      options?: IRenderOptions,
+    ): string;
     /**
       Parse text in a specified format and render it into another format
        @param outputType content type for the output
@@ -159,7 +202,12 @@ declare module 'tiddlywiki' {
       - variables: hashmap of variables to set
       - parentWidget: optional parent widget for the root node
     */
-    renderText(outputType: OutputMimeTypes, textType: TextMimeTypes, text: string, options?: Partial<IMakeWidgetOptions> & IParserOptions): string;
+    renderText(
+      outputType: OutputMimeTypes,
+      textType: TextMimeTypes,
+      text: string,
+      options?: Partial<IMakeWidgetOptions> & IParserOptions,
+    ): string;
     /**
       Make a widget tree for a parse tree
       @params parser: parser object
@@ -203,7 +251,11 @@ declare module 'tiddlywiki' {
     tiddlerExists(title: string): boolean;
     /** Determines if a tiddler is a shadow tiddler, regardless of whether it has been overridden by a real tiddler */
     isShadowTiddler(title: string): boolean;
+    isBinaryTiddler(title: string): boolean;
+    isImageTiddler(title: string): boolean;
     /** return shadowTiddlers[title].source; */
     getShadowSource(title: string): string | null;
+    getTiddlerBacklinks(targetTitle: string): string[];
+    getTiddlerLinks(title: string): string[];
   }
 }

package/src/ast.d.ts

@@ -3,7 +3,13 @@ declare module 'tiddlywiki' {
     end?: number;
     name?: string;
     start?: number;
-    type: 'string' | 'number' | 'bigint' | 'boolean' | 'macro' | 'macro-parameter';
+    type:
+      | 'string'
+      | 'number'
+      | 'bigint'
+      | 'boolean'
+      | 'macro'
+      | 'macro-parameter';
     value: string | IMacroCallParseTreeNode;
   }
 

package/src/modules.d.ts

@@ -15,6 +15,7 @@ declare module 'tiddlywiki' {
   }
   export interface IModuleSandbox {
     $tw: ITiddlyWiki;
+    // eslint-disable-next-line node/prefer-global/buffer
     Buffer?: Buffer;
     clearInterval: typeof clearInterval;
     clearTimeout: typeof clearTimeout;
@@ -26,7 +27,11 @@ declare module 'tiddlywiki' {
     setInterval: typeof setInterval;
     setTimeout: typeof setTimeout;
   }
-  export type TWModuleDefinitionFucntion = (moduleInfo: IModuleInfo, exports: ITWModuleExports, requireFunction: ITWRequire) => void;
+  export type TWModuleDefinitionFucntion = (
+    moduleInfo: IModuleInfo,
+    exports: ITWModuleExports,
+    requireFunction: ITWRequire,
+  ) => void;
   /**
    * Information about each module is kept in an object with these members:
    *
@@ -44,11 +49,21 @@ declare module 'tiddlywiki' {
    */
   interface ITWModules {
     /** Apply the exports of the modules of a particular type to a target object */
-    applyMethods(moduleType: string, targetObject?: ITWModuleExports): ITWModuleExports;
+    applyMethods: (
+      moduleType: string,
+      targetObject?: ITWModuleExports,
+    ) => ITWModuleExports;
     /** Return a class created from a modules. The module should export the properties to be added to those of the optional base class */
-    createClassFromModule(moduleExports: ITWModuleExports, baseClass: new () => unknown): ITWModuleExports;
+    createClassFromModule: (
+      moduleExports: ITWModuleExports,
+      baseClass: new () => unknown,
+    ) => ITWModuleExports;
     /** Return an array of classes created from the modules of a specified type. Each module should export the properties to be added to those of the optional base class */
-    createClassesFromModules(moduleType: string, subType: string | null | undefined, baseClass: new () => unknown): Record<string, ITWModuleExports>;
+    createClassesFromModules: (
+      moduleType: string,
+      subType: string | null | undefined,
+      baseClass: new () => unknown,
+    ) => Record<string, ITWModuleExports>;
     /**
      * Define a JavaScript tiddler module for later execution
      * @param {string} moduleName name of module being defined
@@ -56,12 +71,16 @@ declare module 'tiddlywiki' {
      * @param {(string | TWModuleDefinitionFucntion | ITWModuleExports)} definition module definition; see discussion above
      * @memberof ITWModules
      */
-    define(moduleName: string, moduleType: string, definition: string | TWModuleDefinitionFucntion | ITWModuleExports): void;
+    define: (
+      moduleName: string,
+      moduleType: string,
+      definition: string | TWModuleDefinitionFucntion | ITWModuleExports,
+    ) => void;
     /**
      * Execute the module named 'moduleName'. The name can optionally be relative to the module named 'moduleRoot'
      * @memberof ITWModules
      */
-    execute(moduleName: string, moduleRoot: string): ITWModuleExports;
+    execute: (moduleName: string, moduleRoot: string) => ITWModuleExports;
     /**
      * Apply a callback to each module of a particular type
      *
@@ -69,9 +88,15 @@ declare module 'tiddlywiki' {
      * @param {(title, moduleExports) => void} callback function called as callback(title,moduleExports) for each module
      * @memberof ITWModules
      */
-    forEachModuleOfType(moduleType: string, callback: (title: string, moduleExports: unknown) => void): void;
+    forEachModuleOfType: (
+      moduleType: string,
+      callback: (title: string, moduleExports: unknown) => void,
+    ) => void;
     /** Get all the modules of a particular type in a hashmap by their `name` field */
-    getModulesByTypeAsHashmap(moduleType: string, nameField: string): Record<string, IModuleInfo>;
+    getModulesByTypeAsHashmap: (
+      moduleType: string,
+      nameField: string,
+    ) => Record<string, IModuleInfo>;
     /** hashmap by module name of moduleInfo */
     titles: Record<string, IModuleInfo>;
     /** hashmap by module type and then name of moduleInfo */

package/src/parser.d.ts

@@ -14,10 +14,15 @@ declare module 'tiddlywiki' {
 
   export class WikiParseRule {
     is: { block?: boolean; inline?: boolean };
-    match?: null;
+
+    match?: unknown;
+
     matchRegExp?: RegExp;
+
     parser?: WikiParser;
-    nextTag?: null;
+
+    nextTag?: unknown;
+
     /** `{type: 'macrocall', start: 261, params: Array(1), name: 'reuse-tiddler', end: 290}` */
     nextCall?: {
       end: number;
@@ -29,15 +34,24 @@ declare module 'tiddlywiki' {
     };
   }
   export class WikiParser {
-    blockRules: Array<{ matchIndex?: number; rule: WikiParseRule }>;
-    inlineRules: Array<{ matchIndex?: number; rule: WikiParseRule }>;
-    pragmaRules: Array<{ matchIndex?: number; rule: WikiParseRule }>;
+    blockRules: { matchIndex?: number; rule: WikiParseRule }[];
+
+    inlineRules: { matchIndex?: number; rule: WikiParseRule }[];
+
+    pragmaRules: { matchIndex?: number; rule: WikiParseRule }[];
+
     configTrimWhiteSpace: boolean;
+
     pos: number;
+
     source: string;
+
     sourceLength: number;
+
     type: string;
+
     wiki: Wiki;
+
     tree: IParseTreeNode[];
   }
 }

package/src/server.d.ts

@@ -33,10 +33,8 @@ declare module 'tiddlywiki' {
         wiki - reference to wiki object
   */
   export class Server {
-    constructor(options: IServerOptions);
-    routes: IRoute[];
-    addRoute(route: IRoute): void;
     /**
+     * @example
      * ```json
      * {
           port: "8080",
@@ -71,9 +69,15 @@ declare module 'tiddlywiki' {
       'use-browser-cache': string;
     };
 
+    requestHandler: ServerEndpointHandler;
+
     variables: Record<string, any>;
+
+    routes: IRoute[];
+
+    constructor(options: IServerOptions);
+    addRoute(route: IRoute): void;
     get(variableName: string): any;
-    requestHandler: ServerEndpointHandler;
     /**
       Listen for requests
       port: optional port number (falls back to value of "port" variable)
@@ -84,12 +88,18 @@ declare module 'tiddlywiki' {
 
     on(eventName: 'error', callback: (error: Error) => void): void;
     on(eventName: 'listening', callback: () => void): void;
-    on(eventName: string, callback: (...arguments_: unknown[]) => unknown): void;
+    on(
+      eventName: string,
+      callback: (...arguments_: unknown[]) => unknown,
+    ): void;
 
     /**
       Check whether a given user is authorized for the specified authorizationType ("readers" or "writers"). Pass null or undefined as the username to check for anonymous access
     */
-    isAuthorized(authorizationType: 'readers' | 'writers', username?: string | undefined): boolean;
+    isAuthorized(
+      authorizationType: 'readers' | 'writers',
+      username?: string | undefined,
+    ): boolean;
     close(): void;
   }
 
@@ -103,7 +113,7 @@ declare module 'tiddlywiki' {
    * @link https://talk.tiddlywiki.org/t/what-is-the-state-in-server-route-handler/2877
    */
   export type ServerEndpointHandler<T = Record<string, unknown>> = (
-    request: Http.ClientRequest,
+    request: Http.ClientRequest & Http.InformationEvent,
     response: Http.ServerResponse,
     context: ServerEndpointContext & T,
   ) => void;

package/src/tw.d.ts

@@ -31,7 +31,10 @@ declare module 'tiddlywiki' {
   }
 
   export interface ILanguage {
-    getString(key: string, options: { variables: { title: string } }): string;
+    getString: (
+      key: string,
+      options: { variables: { title: string } },
+    ) => string;
   }
 
   export interface IContentTypeInfo {
@@ -41,22 +44,28 @@ declare module 'tiddlywiki' {
     flags: string[];
   }
 
+  export interface IStartUpOption {
+    bootPath?: string;
+    callback?: () => unknown;
+  }
+
   export interface ITiddlyWiki {
     Tiddler: typeof Tiddler;
     Wiki: typeof Wiki;
 
     boot: {
       argv: string[];
-      boot(callback?: () => unknown): void;
+      boot: (callback?: () => void) => void;
       files: IBootFilesIndex;
-      log(logString: string): void;
+      log: (logString: string) => void;
       logMessages: string[];
-      startup(options: { callback?: () => unknown }): void;
+      startup: (options: IStartUpOption) => void;
       /** Default boot tasks */
       tasks: {
         readBrowserTiddlers: boolean;
         trapErrors: boolean;
       };
+      excludeRegExp: RegExp;
     };
 
     browser: null | {
@@ -112,15 +121,24 @@ declare module 'tiddlywiki' {
       /**
         Add hooks to the  hashmap
       */
-      addHook(hookName: 'th-server-command-post-start', callback: (listenCommand: unknown, server: Server) => void): void;
-      addHook(hookName: string, callback: (...arguments_: unknown[]) => unknown): void;
+      addHook: (
+        hookName: 'th-server-command-post-start',
+        callback: (listenCommand: unknown, server: Server) => void,
+      ) => void;
+      addHook: (
+        hookName: string,
+        callback: (...arguments_: unknown[]) => unknown,
+      ) => void;
       /**
         Invoke the hook by key
       */
-      invokeHook(hookName: string, event: IWidgetEvent): undefined | IWidgetEvent;
+      invokeHook: (
+        hookName: string,
+        event: IWidgetEvent,
+      ) => undefined | IWidgetEvent;
     };
     /** Determines if a tiddler is a shadow tiddler, regardless of whether it has been overridden by a real tiddler */
-    isShadowTiddler(title: string): boolean;
+    isShadowTiddler: (title: string) => boolean;
     language: ILanguage;
     modules: ITWModules;
 
@@ -131,17 +149,28 @@ declare module 'tiddlywiki' {
 
     notifier: Notifier;
     /** Convenience function for pushing a tiddler onto the preloading array */
-    preloadTiddler(fields: Record<string, unknown>): void;
+    preloadTiddler: (fields: Record<string, unknown>) => void;
     /** Convenience function for pushing an array of tiddlers onto the preloading array */
-    preloadTiddlerArray(fieldsArray: Array<Record<string, unknown>>): void;
+    preloadTiddlerArray: (fieldsArray: Array<Record<string, unknown>>) => void;
 
     /** External JavaScript can populate this array before calling boot.js in order to preload tiddlers */
     preloadTiddlers: Record<string, Record<string, unknown>>;
 
+    getLibraryItemSearchPaths: (libraryPath: string, envVar?: string) => string;
+
+    findLibraryItem: (name: string, paths: string[]) => string | null;
+
+    loadMetadataForFile: (filepath: string) => ITiddlerFields | null;
+
+    loadPluginFolder: (
+      filepath: string,
+      excludeRegExp?: RegExp,
+    ) => ITiddlerFields | null;
+
     rootWidget: Widget;
 
     /** Test for the existence of a tiddler (excludes shadow tiddlers) */
-    tiddlerExists(title: string): boolean;
+    tiddlerExists: (title: string) => boolean;
     utils: ITWUtils;
     version: string;
     wiki: Wiki;

package/src/utils.d.ts

@@ -5,9 +5,11 @@ declare module 'tiddlywiki' {
   export type TWDocument = Document;
   export type TWDOMElement = Element;
   /** Callback is invoked with (element, index, object), if callback returns false, then the each loop will be terminated. */
-  export type TWEachCallback<O, I> =
-    | ((element?: I, indexOrKey?: string | number, object?: O) => boolean | undefined)
-    | ((element?: I, indexOrKey?: string | number, object?: O) => void);
+  export type TWEachCallback<O, I> = (
+    element?: I,
+    indexOrKey?: string | number,
+    object?: O,
+  ) => boolean | void;
   export interface ITWUtils {
     Crypto: typeof Crypto;
     PasswordPrompt: typeof PasswordPrompt;
@@ -17,7 +19,7 @@ declare module 'tiddlywiki' {
      * @param element
      * @param className
      */
-    addClass(element: Element, className: string): void;
+    addClass: (element: Element, className: string) => void;
     /**
       Attach specified event handlers to a DOM node
       @param domNode: where to attach the event handlers
@@ -28,27 +30,38 @@ declare module 'tiddlywiki' {
       - handlerObject: optional event handler object
       - handlerMethod: optionally specifies object handler method name (defaults to `handleEvent`)
     */
-    addEventListeners(
+    addEventListeners: (
       domNode: Node,
-      events: Array<{ handlerFunction?: (event: MouseEvent) => void; handlerMethod?: string; handlerObject?: Widget; name: string }>,
-    ): void;
+      events: {
+        handlerFunction?: (event: MouseEvent) => void;
+        handlerMethod?: string;
+        handlerObject?: Widget;
+        name: string;
+      }[],
+    ) => void;
     /** Returns true if the version string A is greater than the version string B. Returns true if the versions are the same */
-    checkVersions(versionStringA: string, versionStringB: string): boolean;
+    checkVersions: (versionStringA: string, versionStringB: string) => boolean;
     /**
      * Returns +1 if the version string A is greater than the version string B, 0 if they are the same, and +1 if B is greater than A.
      * Missing or malformed version strings are parsed as 0.0.0
      */
-    compareVersions(versionStringA: string, versionStringB: string): -1 | 0 | 1;
+    compareVersions: (
+      versionStringA: string,
+      versionStringB: string,
+    ) => -1 | 0 | 1;
     /*
       Return the number of keys in an object
     */
-    count(object: Record<string, any>): number;
+    count: (object: Record<string, any>) => number;
     /** Convert a URIComponent encoded string to a string safely */
-    decodeURIComponentSafe(uri: string): string;
+    decodeURIComponentSafe: (uri: string) => string;
     /** Convert a URI encoded string to a string safely */
-    decodeURISafe(uri: string): string;
+    decodeURISafe: (uri: string) => string;
     /** Fill in any null or undefined properties of an object with the properties from a list of source objects. Each property that is an object is called recursively */
-    deepDefaults(object: object, ...sourceObjectList: object[]): object;
+    deepDefaults: (
+      origin: Record<string | symbol, unknown>,
+      ...defaults: Record<string | symbol, unknown>[]
+    ) => Record<string | symbol, unknown>;
     /**
      * Helper for making DOM elements
      * @param {string} tag tag name
@@ -74,7 +87,7 @@ declare module 'tiddlywiki' {
      * * eventListeners: array of event listeners (this option won't work until `$tw.utils.addEventListeners()` has been loaded)
      * @returns {Element}
      */
-    domMaker(
+    domMaker: (
       tag: string,
       options: {
         attributes?: Record<string, unknown>;
@@ -87,49 +100,66 @@ declare module 'tiddlywiki' {
         style?: Record<string, string>;
         text?: string;
       },
-    ): TWDOMElement;
+    ) => TWDOMElement;
     /**
      * Iterate through all the own properties of an object or array.
      * Callback is invoked with (element, index, object), if callback returns false, then the each loop will be terminated.
      */
-    each<I = any>(object: Record<string, I> | I[], callback: TWEachCallback<Record<string, I> | I[], I>): void;
+    each: <I = any>(
+      object: Record<string, I> | I[],
+      callback: TWEachCallback<Record<string, I> | I[], I>,
+    ) => void;
     /** Display an error and exit */
-    error(error: Event | string): void;
+    error: (error: Event | string) => void;
     /** Run code globally with specified context variables in scope */
-    evalGlobal(code: string, context: IModuleSandbox, filename: string): unknown;
+    evalGlobal: (
+      code: string,
+      context: IModuleSandbox,
+      filename: string,
+    ) => unknown;
     /** Run code in a sandbox with only the specified context variables in scope */
-    evalSandboxed(code: string, context: IModuleSandbox, filename: string): unknown;
+    evalSandboxed: (
+      code: string,
+      context: IModuleSandbox,
+      filename: string,
+    ) => unknown;
     /** Extend an object with the properties from a list of source objects */
-    extend(object: object, ...sourceObjectList: object[]): object;
+    extend: (
+      origin: Record<string | symbol, unknown>,
+      ...sources: Record<string | symbol, unknown>[]
+    ) => Record<string | symbol, unknown>;
     /** the function behind `<<now "format">> */
-    formatDateString(date: Date, format: string): string;
+    formatDateString: (date: Date, format: string) => string;
     /** Given an extension, always access the $tw.config.fileExtensionInfo using a lowercase extension only. */
-    getFileExtensionInfo(extension: string): IFileExtensionInfo | null;
+    getFileExtensionInfo: (extension: string) => IFileExtensionInfo | null;
     /** Get the browser location.hash. We don't use location.hash because of the way that Firefox auto-urldecodes it (see http://stackoverflow.com/questions/1703552/encoding-of-window-location-hash) */
-    getLocationHash(): string;
+    getLocationHash: () => string;
     /** Given an extension, get the correct encoding for that file. defaults to utf8 */
-    getTypeEncoding(extension: string): string;
+    getTypeEncoding: (extension: string) => string;
     /** Check if an object has a property. */
-    hop(object: object, property: string): boolean;
+    hop: (object: object, property: string) => boolean;
     /** Convert "&amp;" to &, "&nbsp;" to nbsp, "&lt;" to <, "&gt;" to > and "&quot;" to " */
-    htmlDecode(text: string): string;
+    htmlDecode: (text: string) => string;
     /** Determine if a value is an array. */
-    isArray(value: unknown): boolean;
+    isArray: (value: unknown) => boolean;
     /** Check if an array is equal by value and by reference. */
-    isArrayEqual(array1: unknown[], array2: unknown[]): boolean;
+    isArrayEqual: (array1: unknown[], array2: unknown[]) => boolean;
     /** Determine if a value is a date */
-    isDate(value: unknown): void;
+    isDate: (value: unknown) => void;
     /** Pad a string to a given length with "0"s. Length defaults to 2 */
-    pad(value: number, length?: number): string;
+    pad: (value: number, length?: number) => string;
     /** Parse a date from a UTC YYYYMMDDHHMMSSmmm format string */
-    parseDate(value: string | Date): Date;
+    parseDate: (value: string | Date) => Date;
     /** Parse a block of name:value fields. The `fields` object is used as the basis for the return value */
-    parseFields(text: string, fields?: object): object;
-    parseJSONSafe(input: string): any;
+    parseFields: (text: string, fields?: object) => object;
+    parseJSONSafe: (input: string) => any;
     /** Parse a string array from a bracketted list. For example "OneTiddler [[Another Tiddler]] LastOne" */
-    parseStringArray(value: string | string[], allowDuplicate?: boolean): string[];
+    parseStringArray: (
+      value: string | string[],
+      allowDuplicate?: boolean,
+    ) => string[];
     /** Parse a semantic version string into its constituent parts -- see https://semver.org */
-    parseVersion(version: string): {
+    parseVersion: (version: string) => {
       build?: string;
       major: number;
       minor: number;
@@ -142,7 +172,7 @@ declare module 'tiddlywiki' {
      * * array: array to modify (assumed to be free of duplicates)
      * * value: a single value to push or an array of values to push
      */
-    pushTop(array: unknown[], value: unknown): void;
+    pushTop: (array: unknown[], value: unknown) => void;
     /**
      * Register file type information
      * @param {string} contentType
@@ -155,7 +185,7 @@ declare module 'tiddlywiki' {
      * * flags:"image" for image types
      * * deserializerType: defaults to type if not specified
      */
-    registerFileType(
+    registerFileType: (
       contentType: string,
       encoding: string,
       extension: string | string[],
@@ -163,17 +193,31 @@ declare module 'tiddlywiki' {
         deserializerType?: string;
         flags?: string[];
       },
-    ): void;
+    ) => void;
     /**
      * Resolves a source filepath delimited with `/` relative to a specified absolute root filepath.
      * In relative paths, the special folder name `..` refers to immediate parent directory, and the
      * name `.` refers to the current directory
      */
-    resolvePath(sourcepath: string, rootpath: string): string;
+    resolvePath: (sourcepath: string, rootpath: string) => string;
     /** Convert a date into UTC YYYYMMDDHHMMSSmmm format */
-    stringifyDate(value: Date): string;
+    stringifyDate: (value: Date) => string;
     /** Stringify an array of tiddler titles into a list string */
-    stringifyList(value: string[]): string;
+    stringifyList: (value: string[]) => string;
+    generateTiddlerFilepath: (
+      title: string,
+      options?: {
+        directory?: string;
+        extension?: string;
+        fileInfo?: {
+          originalpath?: string;
+          filePath?: string;
+          writeError?: boolean;
+        };
+        pathFilters?: string[];
+        wiki?: Wiki;
+      },
+    ) => string;
   }
   /**
    * Notifier mechanism

package/src/widget.d.ts

@@ -36,40 +36,65 @@ declare module 'tiddlywiki' {
     widget: Widget;
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+  // eslint-disable-next-line @typescript-eslint/naming-convention, @typescript-eslint/no-extraneous-class
   class variablesConstructor {}
 
   /**
    * @link https://tiddlywiki.com/dev/#Widgets
    */
   export class Widget {
-    constructor(parseTreeNode: IParseTreeNode, options?: unknown);
-    initialize(parseTreeNode: IParseTreeNode, options?: unknown): void;
     parseTreeNode: IParseTreeNode;
+
     wiki: ITiddlyWiki;
+
     document: IFakeDocument;
+
     parentWidget?: Widget;
+
     /** we can use $tw.rootWidget.widgetClasses.widget to new a widget
      *
      * This is a set of all widgets defined in tiddlywiki.
      */
     widgetClasses: Record<string, Widget>;
+
     /** we can use $tw.rootWidget.widgetClasses.widget to new a widget
      *
      * Like `new widget.widget(widgetNode,{` in `$tw.wiki.makeWidget`
      */
     widget: new (parseTreeNode: IParseTreeNode, options?: unknown) => Widget;
+
     children: Widget[];
+
+    variablesConstructor: variablesConstructor;
+
+    variables: unknown;
+
+    domNodes: Node[];
+
+    parentDomNode: Node;
+
+    constructor(parseTreeNode: IParseTreeNode, options?: unknown);
+    initialize(parseTreeNode: IParseTreeNode, options?: unknown): void;
     /**
       Make child widgets correspondng to specified parseTreeNodes
       And push them to `this.children`
       @param parseTreeNodes default to `this.parseTreeNode.children`, can be undefined
     */
-    makeChildWidgets(parseTreeNodes?: IParseTreeNode[], options?: { variables?: unknown }): void;
+    makeChildWidgets(
+      parseTreeNodes?: IParseTreeNode[],
+      options?: { variables?: unknown },
+    ): void;
     /*
       Initialise widget properties. These steps are pulled out of the constructor so that we can reuse them in subclasses
     */
-    initialise(parseTreeNode: IParseTreeNode, options?: { document?: Document; parentWidget?: Widget; wiki?: ITiddlyWiki }): void;
+    initialise(
+      parseTreeNode: IParseTreeNode,
+      options?: {
+        document?: Document;
+        parentWidget?: Widget;
+        wiki?: ITiddlyWiki;
+      },
+    ): void;
     /**
      * Remove any DOM nodes created by this widget or its children
      *
@@ -82,14 +107,17 @@ declare module 'tiddlywiki' {
       options include:
         variables: optional hashmap of variables to wrap around the widget
     */
-    makeChildWidget(parseTreeNode: IParseTreeNode, options?: { variables?: unknown }): Widget;
-    variablesConstructor: variablesConstructor;
-    variables: unknown;
-    domNodes: Node[];
+    makeChildWidget(
+      parseTreeNode: IParseTreeNode,
+      options?: { variables?: unknown },
+    ): Widget;
     /**
       Add an event listener
     */
-    addEventListener(type: string, handler: (event: IWidgetEvent) => void | Promise<void>): void;
+    addEventListener(
+      type: string,
+      handler: (event: IWidgetEvent) => void | Promise<void>,
+    ): void;
     /**
       Dispatch an event to a widget. If the widget doesn't handle the event then it is also dispatched to the parent widget
 
@@ -99,15 +127,19 @@ declare module 'tiddlywiki' {
     /**
       Add a list of event listeners from an array [{type:,handler:},...]
     */
-    addEventListeners(listeners: Array<{ handler: (event: IWidgetEvent) => void | Promise<void>; type: string }>): void;
+    addEventListeners(
+      listeners: Array<{
+        handler: (event: IWidgetEvent) => void | Promise<void>;
+        type: string;
+      }>,
+    ): void;
 
-    parentDomNode: Node;
     /**
       Compute the internal state of the widget.
       This will be automatically called in the `render` method.
 
       For example, `getAttribute` and set them to class members.
-      
+
     */
     execute(): void;
     /**
@@ -126,7 +158,10 @@ declare module 'tiddlywiki' {
      * @param event
      * @returns handled
      */
-    invokeAction(triggeringWidget: Widget, event: IWidgetEvent): boolean | undefined;
+    invokeAction(
+      triggeringWidget: Widget,
+      event: IWidgetEvent,
+    ): boolean | undefined;
 
     /**
      * Lifecycle method: Render this widget into the DOM
@@ -146,8 +181,10 @@ declare module 'tiddlywiki' {
     /**
       Refresh all the children of a widget
       will call `this.render`
+
+      Need to call this after `setVariable`
     */
-    refreshChildren(changedTiddlers: IChangedTiddlers): boolean;
+    refreshChildren(changedTiddlers?: IChangedTiddlers): boolean;
     /**
      * Rebuild a previously rendered widget
      */
@@ -173,7 +210,7 @@ declare module 'tiddlywiki' {
      * Simplified version of getVariableInfo() that just returns the text.
      * @param name variable name, for example, `currentTiddler` in the widget context
      * @param options options for getVariableInfo()
-     * 
+     *
      * Options include
         params: array of {name:, value:} for each parameter
         defaultValue: default value if the variable is not defined
@@ -184,6 +221,20 @@ declare module 'tiddlywiki' {
         text: text of variable, with parameters properly substituted
      */
     getVariable(name: string, options?: object): string;
+    /**
+      Set the value of a context variable
+
+      @param name name of the variable
+      @param value value of the variable
+      @param params array of {name:, default:} for each parameter
+      @param isMacroDefinition true if the variable is set via a \define macro pragma (and hence should have variable substitution performed)
+      */
+    setVariable(
+      name: string,
+      value: string,
+      parameters?: object[],
+      isMacroDefinition?: boolean,
+    ): void;
   }
 
   export interface IFakeDocument {
@@ -194,6 +245,7 @@ declare module 'tiddlywiki' {
     isTiddlyWikiFakeDom: boolean;
     setSequenceNumber: (value: any) => void;
   }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
   export interface TW_Element extends HTMLElement {
     _style: Record<string, unknown>;
     appendChild: <T extends TW_Element | TW_TextNode | Node>(node: T) => T;
@@ -202,13 +254,13 @@ declare module 'tiddlywiki' {
     namespaceURI: string;
     tag: string;
   }
+  // eslint-disable-next-line @typescript-eslint/naming-convention
   export interface TW_TextNode extends Node {
     textContent: string;
   }
 
-  export interface ModalWidget {
-    new (wiki: Wiki): ModalWidget;
-    adjustPageClass(): void;
+  export type ModalWidget = {
+    adjustPageClass: () => void;
     /**
      *
      * @param title
@@ -216,6 +268,15 @@ declare module 'tiddlywiki' {
      * variables: optional hashmap of variables to wrap around the widget
      * downloadLink: normally is used for "Right-click to save changes"
      */
-    display(title: string, options?: { downloadLink?: string; event?: IWidgetEvent; variables?: unknown }): void;
-  }
+    display: (
+      title: string,
+      options?: {
+        downloadLink?: string;
+        event?: IWidgetEvent;
+        variables?: unknown;
+      },
+    ) => void;
+
+    new (wiki: Wiki): ModalWidget;
+  };
 }