tw5-typed 0.0.7 → 0.0.11

package/package.json

@@ -2,7 +2,7 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.0.7",
+  "version": "0.0.11",
   "url": "https://github.com/tiddly-gittly/tw5-typed",
   "homepage": "https://github.com/tiddly-gittly/tw5-typed",
   "bugs": {
@@ -20,21 +20,27 @@
     "prepublishOnly": "npx tsc --noEmit"
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "5.10.2",
-    "@typescript-eslint/parser": "5.10.2",
-    "typescript": "4.5.5",
+    "@typescript-eslint/eslint-plugin": "5.11.0",
+    "@typescript-eslint/parser": "5.11.0",
     "eslint": "8.8.0",
     "eslint-config-prettier": "8.3.0",
     "eslint-config-standard": "17.0.0-1",
     "eslint-config-standard-with-typescript": "21.0.1",
     "eslint-import-resolver-alias": "1.1.2",
     "eslint-import-resolver-typescript": "2.5.0",
+    "eslint-plugin-html": "6.2.0",
     "eslint-plugin-import": "2.25.4",
+    "eslint-plugin-n": "14.0.0",
     "eslint-plugin-node": "11.1.0",
     "eslint-plugin-prettier": "4.0.0",
+    "eslint-plugin-promise": "6.0.0",
+    "eslint-plugin-react": "7.28.0",
+    "eslint-plugin-react-hooks": "4.3.0",
+    "eslint-plugin-security": "1.4.0",
+    "eslint-plugin-security-node": "1.1.1",
     "eslint-plugin-typescript-sort-keys": "2.1.0",
     "eslint-plugin-unicorn": "40.1.0",
-    "prettier": "2.5.1"
-  },
-  "dependencies": {}
+    "prettier": "2.5.1",
+    "typescript": "4.5.5"
+  }
 }

package/src/Crypto.d.ts

@@ -0,0 +1,9 @@
+declare module 'tiddlywiki' {
+  export class Crypto {
+    setPassword(newPassword: string): void;
+    updateCryptoStateTiddler(): void;
+    hasPassword(): boolean;
+    encrypt(text: string, password: string): string | null;
+    decrypt(text: string, password: string): string | null;
+  }
+}

package/src/PasswordPrompt.d.ts

@@ -0,0 +1,54 @@
+declare module 'tiddlywiki' {
+  export interface PasswordPromptInfo {
+    callback: PasswordPromptInfoCallback;
+    form: TWDOMElement;
+    owner: PasswordPrompt;
+    serviceName: string;
+  }
+
+  export type PasswordPromptInfoCallback = (
+    data: {
+      password: string;
+      password2?: string;
+      username: string;
+    } | null,
+  ) => boolean;
+
+  export class PasswordPrompt {
+    /** Creates a PasswordPrompt object */
+    constructor();
+    /** Store of pending password prompts */
+    passwordPrompts: PasswordPromptInfo[];
+    promptWrapper: TWDOMElement;
+    /** Hides or shows the wrapper depending on whether there are any outstanding prompts */
+    setWrapperDisplay(): void;
+    /**
+     * Adds a new password prompt. Options are:
+     * @param {{
+     *       submitText: string;
+     *       serviceName: string;
+     *       noUserName: boolean;
+     *       canCancel: boolean;
+     *       repeatPassword: boolean;
+     *       callback: PasswordPromptInfoCallback;
+     *     }} options Options are:
+     * * submitText: text to use for submit button (defaults to "Login")
+     * * serviceName: text of the human readable service name
+     * * noUserName: set true to disable username prompt
+     * * canCancel: set true to enable a cancel button (callback called with null)
+     * * repeatPassword: set true to prompt for the password twice
+     * * callback: function to be called on submission with parameter of object {username:,password:}. Callback must return `true` to remove the password prompt
+     * @returns {PasswordPromptInfo}
+     * @memberof PasswordPrompt
+     */
+    createPrompt(options: {
+      callback: PasswordPromptInfoCallback;
+      canCancel: boolean;
+      noUserName: boolean;
+      repeatPassword: boolean;
+      serviceName: string;
+      submitText: string;
+    }): PasswordPromptInfo;
+    removePrompt(promptInfo: PasswordPromptInfo): void;
+  }
+}

package/src/Tiddler.d.ts

@@ -0,0 +1,25 @@
+declare module 'tiddlywiki' {
+  export class Tiddler {
+    constructor(...fields: Array<Record<string, unknown> | Tiddler>);
+    readonly cache: ITiddlerCache;
+    readonly fields: ITiddlerFields;
+    static fieldModules: IModule;
+    hasField(field: string): boolean;
+    isEqual(tiddler: Tiddler, excludeFields: string[]): boolean;
+  }
+
+  export interface ITiddlerFields {
+    readonly [anyKey: string]: unknown;
+    readonly color: string;
+    readonly created: Date;
+    readonly list: string[];
+    readonly modified: Date;
+    readonly tags: string[];
+    readonly text: string;
+    readonly title: string;
+    readonly type: string;
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  export interface ITiddlerCache {}
+}

package/src/Wiki.d.ts

@@ -0,0 +1,17 @@
+declare module 'tiddlywiki' {
+  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.
+     * @param {{ enableIndexers: unknown[] }} options options include:
+     * * enableIndexers - Array of indexer names to enable, or null to use all available indexers
+     * @memberof Wiki
+     */
+    constructor(options: { enableIndexers: unknown[] });
+    addIndexer(indexer, name): void;
+    getTiddler: (title: string) => Tiddler | undefined;
+    /**
+     * Get full list of tiddler titles in the wiki
+     */
+    getTiddlers: () => string[];
+  }
+}

package/src/filter-operator.d.ts

@@ -1,42 +1,152 @@
 declare module 'tiddlywiki' {
-  export type SourceIterator = (tiddler: Object, title: string) => void;
+  /**
+   * # 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.
+
+Each function will be called with three arguments:
+
+*   A [tiddler iterator](#Tiddler%20Iterators) representing the results of the previous filter step (or all tiddlers, if this filter appears first in an expression), conventionally named `source`.
+*   An object, conventionally called `operator`, representing the arguments for this filter step, with the following keys:
+
+    *   *operator*: the name of the filter operator specified in the [WikiText](#WikiText);
+    *   *operand*: the operand for the filter step (as a string; if the filter specified it in angle brackets or braces, the text reference or variable name will have already been resolved);
+    *   *prefix*: (optional) a string containing a single exclamation mark if the filter operator is to be negated;
+    *   *suffix*: (optional) a string containing an additional filter argument (typically a tiddler field name) following the filter name (separated by a colon in the filter syntax);
+    *   *regexp*: (optional, deprecated) used instead of *operand* if the filter operand is a regexp.
+*   An object, conventionally called `options`, with the following keys:
+
+    *   *wiki*: The `$tw.Wiki` object;
+    *   *widget*: (optional) a widget node.
+
+The function should return either a new [tiddler iterator](#Tiddler%20Iterators), or else an array of tiddler titles (as strings). The underlying filter mechanism will convert back and forth between iterators and arrays as needed.
+
+# References
+
+There are several filter operators built into the core which can serve as a jumping off point for your own filter operators:
+
+[https://github.com/Jermolene/TiddlyWiki5/tree/master/core/modules/filters](https://github.com/Jermolene/TiddlyWiki5/tree/master/core/modules/filters)
+
+# Example
+
+Suppose we want to make a filter operator that returns every other tiddler from the input list. A typical invocation might look like `[tags[interesting]everyother[]]`.
+
+We make a new tiddler, set its `type` and `module-type` appropriately, and begin writing the code:
+
+```js
+(function(){
+  "use strict";
+  exports.everyother = function(source, operator, options) {
+      // TODO
+  }
+})();
+```
+
+For the example filter syntax, our function will be called with
+
+*   source: an iterator over all the tiddlers tagged as `interesting`
+*   operator: an object `{operator: "everyother", operand: ""}`
+*   options: an object with the current Wiki object and a widget object, neither of which we need
+
+As is usually the case, we don't care about `operator.operator` here (since that information has already been used to look up our function); we also don't care about `operator.operand`, since there is no meaningful operand for this operation.
+
+We could implement the operator by iterating over the input tiddlers and explicitly building a result array of titles:
+
+```js
+(function(){
+  "use strict";
+  exports.everyother = function(source, operator, options) {
+      var result = [];
+      var include = true;
+      source(function(tiddler, title) {
+          if (include) { result.push(title); }
+          include = !include;
+      });
+      return result;
+  }
+})();
+```
+
+That is, we supply a callback to `source` that negates `include` each time through (in order to grab every other result) and pushes the `title` of every other tiddler onto the result.
+
+Alternatively, we can return our own iterator, by returning a function that accepts a similar callback and only calls it on every other tiddler:
+
+```js
+(function(){
+  "use strict";
+  exports.everyother = function(source, operator, options) {
+      return function(callback) {
+          var include = true;
+          source(function(tiddler, title) {
+              if (include) { callback(tiddler, title); }
+              include = !include;
+          });
+      };
+  }
+})();
+```
+
+Either way, we could interpret the `!` flag on the filter, if present, to mean that we want the *other* half of the tiddlers, by using it to set the initial value of `include`: `var include = operator.prefix !== "!";`
+
+# Filter Behaviour
+
+As with [JavaScript Macros](#JavaScript%20Macros), filter operators should not make modifications to tiddlers, but only return a list of tiddlers or a tiddler iterator.
+
+   */
+  export type IFilterOperator = (source: (iter: SourceIterator) => void, operator: IFilterOperatorParamOperator) => string[] | ((iter: SourceIterator) => void);
+
+  /**
+   * A [tiddler iterator](#Tiddler%20Iterators) representing the results of the previous filter step (or all tiddlers, if this filter appears first in an expression), conventionally named `source`.
+   * 
+   * For Example, with an iterator over all the tiddlers tagged as `interesting`, use it like this:
+   * 
+   * ```js
+   * var result = [];
+      var include = true;
+      source(function(tiddler, title) {
+          if (include) { result.push(title); }
+          include = !include;
+      });
+    ```
+   */
+  export type SourceIterator = (tiddler: Tiddler, title: string) => void;
   export interface ISearchOptions {
-    /** an iterator function for the source tiddlers, called source(iterator), where iterator is called as iterator(tiddler,title) */
-    source?: (iter: SourceIterator) => 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 forces a case sensitive search */
+    caseSensitive?: boolean;
+    /** An array of tiddler titles to exclude from the search */
+    exclude?: string[];
     /** If true, the field options are inverted to specify the fields that are not to be searched */
     excludeField?: boolean;
+    /** If specified, restricts the search to the specified field, or an array of field names */
+    field?: string | string[];
+    /** If true returns tiddlers that do not contain the specified string */
+    invert?: boolean;
     /** searches for literal string */
     literal?: boolean;
+    /** an iterator function for the source tiddlers, called source(iterator), where iterator is called as iterator(tiddler,title) */
+    source?: (iter: SourceIterator) => void;
     /** same as literal except runs of whitespace are treated as a single space */
     whitespace?: boolean;
     /** (default) treats search string as a list of tokens, and matches if all tokens are found, regardless of adjacency or ordering */
     words?: boolean;
   }
 
-  export interface IFilterOperatorParamOperator {
-    /** the name of the filter operator specified in the WikiText; */
-    operator: string;
+  export interface IFilterOperatorParameterOperator {
     /** the operand for the filter step (as a string; if the filter specified it in angle brackets or braces, the text reference or letiable name will have already been resolved); */
     operand: string;
+    /** the name of the filter operator specified in the WikiText; */
+    operator: string;
     /** (optional) a string containing a single exclamation mark if the filter operator is to be negated; */
     prefix?: string;
+    /** (optional, deprecated) used instead of `operand` if the filter operand is a regexp. */
+    regexp?: string;
     /** (optional) a string containing an additional filter argument (typically a tiddler field name) following the filter name (separated by a colon in the filter syntax); */
     suffix?: string;
     /** multiple suffix
      * for example, in `search:<field list>:<flag list>[<operand>]`, you will get `<field list>` as suffixes[0], and `<flag list>` as suffixes[1]
      */
     suffixes?: string[][];
-    /** (optional, deprecated) used instead of `operand` if the filter operand is a regexp. */
-    regexp?: string;
   }
 }

package/src/modules.d.ts

@@ -0,0 +1,80 @@
+declare module 'tiddlywiki' {
+  export interface ITWModuleExports {
+    [exportName: unknown]: unknown;
+    name?: string;
+    type?: string;
+  }
+  export interface IModuleInfo {
+    definition: string | TWModuleDefinitionFucntion | ITWModuleExports;
+    exports: ITWModuleExports | null;
+    moduleType: string;
+  }
+  export interface ITWRequire {
+    (title: string): ITWModuleExports;
+    readonly main: NodeJS.Module | { TiddlyWiki: typeof TiddlyWiki };
+  }
+  export interface IModuleSandbox {
+    $tw: ITiddlyWiki;
+    Buffer?: Buffer;
+    clearInterval: typeof clearInterval;
+    clearTimeout: typeof clearTimeout;
+    console: Console;
+    exports: ITWModuleExports;
+    module: { exports: ITWModuleExports; readonly id: string };
+    process?: NodeJS.Process;
+    require: ITWRequire;
+    setInterval: typeof setInterval;
+    setTimeout: typeof setTimeout;
+  }
+  export type TWModuleDefinitionFucntion = (moduleInfo: IModuleInfo, exports: ITWModuleExports, requireFunction: ITWRequire) => void;
+  /**
+   * Information about each module is kept in an object with these members:
+   *
+   * * moduleType: type of module
+   * * definition: object, function or string defining the module; see below
+   * * exports: exports of the module, filled in after execution
+   *
+   * The `definition` can be of several types:
+   *
+   * * An object can be used to directly specify the exports of the module
+   * * A function with the arguments `module,require,exports` that returns `exports`
+   * * A string function body with the same arguments
+   *
+   * Each moduleInfo object is stored in two hashmaps: $tw.modules.titles and $tw.modules.types. The first is indexed by title and the second is indexed by type and then title
+   */
+  interface ITWModules {
+    /** Apply the exports of the modules of a particular type to a target object */
+    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;
+    /** 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>;
+    /**
+     * Define a JavaScript tiddler module for later execution
+     * @param {string} moduleName name of module being defined
+     * @param {string} moduleType type of module
+     * @param {(string | TWModuleDefinitionFucntion | ITWModuleExports)} definition module definition; see discussion above
+     * @memberof ITWModules
+     */
+    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;
+    /**
+     * Apply a callback to each module of a particular type
+     *
+     * @param {string} moduleType type of modules to enumerate
+     * @param {(title, moduleExports) => void} callback function called as callback(title,moduleExports) for each module
+     * @memberof ITWModules
+     */
+    forEachModuleOfType(moduleType: string, callback: (title, moduleExports) => 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>;
+    /** hashmap by module name of moduleInfo */
+    titles: Record<string, IModuleInfo>;
+    /** hashmap by module type and then name of moduleInfo */
+    types: Record<string, Record<string, IModuleInfo>>;
+  }
+}

package/src/tiddlywiki-test.ts

@@ -0,0 +1,18 @@
+/* eslint-disable @typescript-eslint/no-useless-constructor */
+import { Widget as IWidget } from 'tiddlywiki'
+
+const Widget = {} as unknown as IWidget;
+export class ReactWidget extends Widget {
+  constructor(parseTreeNode: any, options: any) {
+    super(parseTreeNode, options);
+  }
+
+  render(parent: Node, nextSibling: Node): void {
+    this.parentDomNode = parent;
+    this.execute();
+    this.computeAttributes();
+    const containerElement = document.createElement('div');
+    this.domNodes.push(containerElement);
+    parent.appendChild(containerElement);
+  }
+}

package/src/tw.d.ts

@@ -1,34 +1,6 @@
-declare module 'tiddlywiki' {
-  export interface ITiddler {
-    constructor(...fields: (Record<string, unknown> | ITiddler)[]);
-    readonly cache: ITiddlerCache;
-    readonly fields: ITiddlerFields;
-    // static fieldModules: IModule;
-    hasField(field: string): boolean;
-    isEqual(tiddler: ITiddler, excludeFields: string[]): boolean;
-  }
-
-  export interface ITiddlerFields {
-    readonly created: Date;
-    readonly list: string[];
-    readonly modified: Date;
-    readonly tags: string[];
-    readonly text: string;
-    readonly title: string;
-    readonly type: string;
-    readonly color: string;
-    readonly [anyKey: string]: unknown;
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  export interface ITiddlerCache {}
+import { Widget } from './widget';
 
-  /**
-   * filepath: '/Users/linonetwo/xxxx/wiki/Meme-of-LinOnetwo/tiddlers/tiddlerTitle.tid',
-   * hasMetaFile: false
-   * tiddlerTitle: string,
-   * type: 'application/x-tiddler',
-   */
+declare module 'tiddlywiki' {
   export interface IBootFilesIndexItem {
     filepath: string;
     hasMetaFile: boolean;
@@ -40,147 +12,70 @@ declare module 'tiddlywiki' {
    */
   export type IBootFilesIndex = Partial<Record<string, IBootFilesIndexItem>>;
 
-  export interface IModule {
-    moduleType: string;
-    definition: unknown;
-    exports: object | null;
+  export interface IPluginInfo {
+    tiddlers: ITiddlerFields[];
   }
 
-  export interface TiddlyWiki {
+  export interface IFileExtensionInfo {
+    type: string;
+  }
+
+  export interface IContentTypeInfo {
+    deserializerType: string;
+    encoding: string;
+    extension: string;
+    flags: string[];
+  }
+
+  export interface ITiddlyWiki {
+    Tiddler: typeof Tiddler;
+    Wiki: typeof Wiki;
+
     boot: {
       argv: string[];
       files: IBootFilesIndex;
+      log(logString: string): void;
+      logMessages: string[];
       startup(options: { callback?: () => unknown }): void;
       /** Default boot tasks */
       tasks: {
-        trapErrors: boolean;
         readBrowserTiddlers: boolean;
+        trapErrors: boolean;
       };
-      logMessages: string[];
-      log(str: string): void;
     };
 
-    /** Broswer features, if tw isn't running on a browser environment, the value will be `null` */
     browser: null | object;
+
+    config: ITWConfig;
+
+    hooks: {
+      addHook: (hookName: string, callback: (...arguments_: unknown[]) => unknown) => void;
+    };
+
+    modules: ITWModules;
     /** NodeJS features, if tw isn't running on a NodeJS environment, the value will be `null` */
     node: null | object;
+    /** Broswer features, if tw isn't running on a browser environment, the value will be `null` */
     nodeWebKit: null | object;
 
-    /**
-     * Information about each module is kept in an object with these members:
-     *
-     * * moduleType: type of module
-     * * definition: object, function or string defining the module; see below
-     * * exports: exports of the module, filled in after execution
-     *
-     * The `definition` can be of several types:
-     *
-     * * An object can be used to directly specify the exports of the module
-     * * A function with the arguments `module,require,exports` that returns `exports`
-     * * A string function body with the same arguments
-     *
-     * Each moduleInfo object is stored in two hashmaps: $tw.modules.titles and $tw.modules.types. The first is indexed by title and the second is indexed by type and then title
-     */
-    modules: {
-      /** hashmap by module name of moduleInfo */
-      titles: Record<string, IModule>;
-      /** hashmap by module type and then name of moduleInfo */
-      types: Record<string, Record<string, IModule>>;
-      /**
-       * Define a JavaScript tiddler module for later execution
-       * @param {string} moduleName name of module being defined
-       * @param {string} moduleType type of module
-       * @param {unknown} definition module definition; see discussion above
-       */
-      define(moduleName: string, moduleType: string, definition: unknown): void;
-    };
-
-    /** External JavaScript can populate this array before calling boot.js in order to preload tiddlers */
-    preloadTiddlers: Record<string, Record<string, unknown>>;
     /** Convenience function for pushing a tiddler onto the preloading array */
     preloadTiddler(fields: Record<string, unknown>): void;
     /** Convenience function for pushing an array of tiddlers onto the preloading array */
-    preloadTiddlerArray(fieldsArray: 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>>;
 
-    hooks: {
-      addHook: (hookName: string, callback: (...arguments_: any[]) => unknown) => void;
-    };
-    wiki: {
-      getTiddler: (title: string) => ITiddler | undefined;
-      /**
-       * Get full list of tiddler titles in the wiki
-       */
-      getTiddlers: () => string[];
-    };
-    utils: {
-      /** Check if an object has a property. */
-      hop(object: object, property: string): boolean;
-      /** Determine if a value is an array. */
-      isArray(value: unknown): boolean;
-      /** Check if an array is equal by value and by reference. */
-      isArrayEqual(array1: unknown[], array2: unknown[]): boolean;
-      /**
-       * Push entries onto an array, removing them first if they already exist in the array
-       *
-       * * 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;
-      /** Determine if a value is a date */
-      isDate(value: unknown): void;
-      /**
-       * 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<T = object | unknown[]>(object: T, callback: (element?: unknown, index?: string | number, object?: T) => boolean | void);
-      /**
-       * Helper for making DOM elements
-       * Options include:
-       * * namespace:
-       * * attributes: hashmap of attribute values
-       * * style: hashmap of styles
-       * * text: text to add as a child node
-       * * children: array of further child nodes
-       * * innerHTML: optional HTML for element
-       * * class: class name(s)
-       * * document: defaults to current document
-       * * eventListeners: array of event listeners (this option won't work until `$tw.utils.addEventListeners()` has been loaded)
-       *
-       * @param {string} tag tag name
-       * @param {{
-       *           namespace?: string;
-       *           attributes?: Record<string, unknown>;
-       *           style?: Record<string, string>;
-       *           text?: string;
-       *           children?: Element[];
-       *           innerHTML?: string;
-       *           class?: string;
-       *           document?: Document;
-       *           eventListeners?: EventListener[];
-       *         }} options
-       * @returns {Element}
-       */
-      domMaker(
-        tag: string,
-        options: {
-          namespace?: string;
-          attributes?: Record<string, unknown>;
-          style?: Record<string, string>;
-          text?: string;
-          children?: Element[];
-          innerHTML?: string;
-          class?: string;
-          document?: Document;
-          eventListeners?: EventListener[];
-        },
-      ): Element;
-    };
-  }
+    rootWidget: Widget;
 
-  export function TiddlyWiki(): TiddlyWiki;
+    utils: ITWUtils;
 
-  global {
-    const $tw: TiddlyWiki;
+    version: string;
+    wiki: Wiki;
   }
+
+  export function TiddlyWiki($tw: object): ITiddlyWiki;
+}
+declare global {
+  const $tw: ITiddlyWiki;
 }
+export {};

package/src/twconfig.d.ts

@@ -0,0 +1,40 @@
+declare module 'tiddlywiki' {
+  declare interface ITWConfig {
+    [configName: string]: unknown;
+    /** Map type to file content type */
+    contentTypeInfo: Record<string, IContentTypeInfo>;
+    /** Default is `TIDDLYWIKI_EDITION_PATH` */
+    editionsEnvVar: string;
+    /** Default is `../editions/` */
+    editionsPath: string;
+    /** Map file extension */
+    fileExtensionInfo: Record<string, IFileExtensionInfo>;
+    /** Default is `^\\/\\*\\\\(?:\\r?\\n)((?:^[^\\r\\n]*(?:\\r?\\n))+?)(^\\\\\\*\\/$(?:\\r?\\n)?)` */
+    jsModuleHeaderRegExpString: string;
+    /** Default is `TIDDLYWIKI_LANGUAGE_PATH` */
+    languagesEnvVar: string;
+    /** Default is `../languages/` */
+    languagesPath: string;
+    //
+    /** Default is `TIDDLYWIKI_PLUGIN_PATH` */
+    pluginsEnvVar: string;
+    /** Default is `../plugins/` */
+    pluginsPath: string;
+    /** Default is `TIDDLYWIKI_THEME_PATH` */
+    themesEnvVar: string;
+    /** Default is `../themes/` */
+    themesPath: string;
+    /** Default is `./tiddlywiki.info` */
+    wikiInfo: string;
+    /** Default is `./languages` */
+    wikiLanguagesSubDir: string;
+    /** Default is `./output` */
+    wikiOutputSubDir: string;
+    /** Default is `./plugins` */
+    wikiPluginsSubDir: string;
+    /** Default is `./themes` */
+    wikiThemesSubDir: string;
+    /** Default is `./tiddlers` */
+    wikiTiddlersSubDir: string;
+  }
+}

package/src/utils.d.ts

@@ -0,0 +1,144 @@
+declare module 'tiddlywiki' {
+  export type TWDocument = Document;
+  export type TWDOMElement = Element;
+  export type TWEachCallback<T> = (element?: unknown, index?: string | number, object?: T) => boolean | undefined;
+  interface ITWUtils {
+    Crypto: typeof Crypto;
+    PasswordPrompt: typeof PasswordPrompt;
+    /** 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;
+    /**
+     * 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;
+    /** Convert a URIComponent encoded string to a string safely */
+    decodeURIComponentSafe(uri: string): string;
+    /** Convert a URI encoded string to a string safely */
+    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;
+    /**
+     * Helper for making DOM elements
+     * @param {string} tag tag name
+     * @param {{
+     *           namespace?: string;
+     *           attributes?: Record<string, unknown>;
+     *           style?: Record<string, string>;
+     *           text?: string;
+     *           children?: Element[];
+     *           innerHTML?: string;
+     *           class?: string;
+     *           document?: Document;
+     *           eventListeners?: EventListener[];
+     *         }} options Options include:
+     * * namespace: defaults to http://www.w3.org/1999/xhtml
+     * * attributes: hashmap of attribute values
+     * * style: hashmap of styles
+     * * text: text to add as a child node
+     * * children: array of further child nodes
+     * * innerHTML: optional HTML for element
+     * * class: class name(s)
+     * * document: defaults to current document
+     * * eventListeners: array of event listeners (this option won't work until `$tw.utils.addEventListeners()` has been loaded)
+     * @returns {Element}
+     */
+    domMaker(
+      tag: string,
+      options: {
+        attributes?: Record<string, unknown>;
+        children?: TWDOMElement[];
+        class?: string;
+        document?: TWDocument;
+        eventListeners?: EventListener[];
+        innerHTML?: string;
+        namespace?: string;
+        style?: Record<string, string>;
+        text?: string;
+      },
+    ): 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<T = object | unknown[]>(object: T, callback: TWEachCallback<T>): void;
+    /** Display an error and exit */
+    error(error: Event | string): void;
+    /** Run code globally with specified context variables in scope */
+    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;
+    /** Extend an object with the properties from a list of source objects */
+    extend(object: object, ...sourceObjectList: object[]): object;
+    /** Given an extension, always access the $tw.config.fileExtensionInfo using a lowercase extension only. */
+    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;
+    /** Given an extension, get the correct encoding for that file. defaults to utf8 */
+    getTypeEncoding(extension: string): string;
+    /** Check if an object has a property. */
+    hop(object: object, property: string): boolean;
+    /** Convert "&amp;" to &, "&nbsp;" to nbsp, "&lt;" to <, "&gt;" to > and "&quot;" to " */
+    htmlDecode(text: string): string;
+    /** Determine if a value is an array. */
+    isArray(value: unknown): boolean;
+    /** Check if an array is equal by value and by reference. */
+    isArrayEqual(array1: unknown[], array2: unknown[]): boolean;
+    /** Determine if a value is a date */
+    isDate(value: unknown): void;
+    /** Pad a string to a given length with "0"s. Length defaults to 2 */
+    pad(value: number, length?: number): string;
+    /** Parse a date from a UTC YYYYMMDDHHMMSSmmm format string */
+    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;
+    /** Parse a string array from a bracketted list. For example "OneTiddler [[Another Tiddler]] LastOne" */
+    parseStringArray(value: string | string[], allowDuplicate?: boolean): string[];
+    /** Parse a semantic version string into its constituent parts -- see https://semver.org */
+    parseVersion(version: string): {
+      build?: string;
+      major: number;
+      minor: number;
+      patch: number;
+      prerelease?: string;
+      version: string;
+    } | null;
+    /**
+     * Push entries onto an array, removing them first if they already exist in the array
+     * * 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;
+    /**
+     * Register file type information
+     * @param {string} contentType
+     * @param {string} encoding
+     * @param {(string | string[])} extension
+     * @param {{
+     *           flags: string[];
+     *           deserializerType: string;
+     *         }} [options] Options includes:
+     * * flags:"image" for image types
+     * * deserializerType: defaults to type if not specified
+     */
+    registerFileType(
+      contentType: string,
+      encoding: string,
+      extension: string | string[],
+      options?: {
+        deserializerType?: string;
+        flags?: string[];
+      },
+    ): 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;
+    /** Convert a date into UTC YYYYMMDDHHMMSSmmm format */
+    stringifyDate(value: Date): string;
+    /** Stringify an array of tiddler titles into a list string */
+    stringifyList(value: string[]): string;
+  }
+}

package/src/widget.d.ts

@@ -1,13 +1,42 @@
-declare class variablesConstructor {
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+declare class variablesConstructor {}
 
-}
-
-export class Widget {
-  constructor(parseTreeNode: any, options: any);
-  initialize: (parseTreeNode: any, options: any) => void;
-  parseTreeNode: any;
-  wiki: any;
+export declare class Widget {
+  constructor(parseTreeNode: unknown, options: unknown);
+  initialize: (parseTreeNode: unknown, options: unknown) => void;
+  parseTreeNode: unknown;
+  wiki: unknown;
   parentWidget?: Widget;
   variablesConstructor: variablesConstructor;
-  variables: any;
+  variables: unknown;
+  domNodes: Node[];
+  /**
+    Add an event listener
+  */
+  addEventListener(type: string, handler: (arguments_: unknown[]) => 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
+  */
+  dispatchEvent(type: string): void;
+  /**
+    Add a list of event listeners from an array [{type:,handler:},...]
+  */
+  addEventListeners(listeners: Array<{ handler: (arguments_: unknown[]) => void; type: string }>): void;
+
+  parentDomNode: Node;
+  execute: () => void;
+
+  /**
+   * Lifecycle method: Render this widget into the DOM
+   */
+  render(parent: Node, nextSibling: Node): void;
+  computeAttributes(): void;
+  /**
+   * Get parameters that user set in the widget
+   * @param name attribute name, for example, `actions` in the button widget
+   */
+  getAttribute(name: string): string;
+}
+declare module 'tiddlywiki' {
+  export type Widget = typeof Widget;
 }