tw5-typed 0.0.4 → 0.0.8

package/README.md

@@ -15,7 +15,7 @@ Add `tw5-typed` to your `tsconfig.json`'s `compilerOptions`
 ```json
 {
   "compilerOptions": {
-    "types": ["node", "tw5-typed"] /* Type declaration files to be included in compilation. */,
+    "types": ["node", "tw5-typed"] /* Type declaration files to be included in compilation. */
   }
 }
 ```
@@ -23,5 +23,33 @@ Add `tw5-typed` to your `tsconfig.json`'s `compilerOptions`
 Then you will have global types like `$tw` automatically. You can import the rest of the types using `import type` statement:
 
 ```typescript
+import type { ISearchOptions, SourceIterator, IFilterOperatorParamOperator } from 'tiddlywiki';
+```
+
+### Alias
+
+Sometimes you may want to use a modified version of tw, you can re-export types like this in your `src/type.d.ts`:
+
+```typescript
+declare module '@tiddlygit/tiddlywiki' {
+  export * from 'tiddlywiki';
+}
+```
 
+## Development
+
+Firstly, Install eslint using npm:
+
+```sh
+npm i
 ```
+
+You can add new `*.d.ts` file to contain your types:
+
+1. use `declare module 'tiddlywiki' { }` to wrap all your types.
+1. don't forget to `export` all your types.
+1. to add type for global variable, add `global { }` inside that `declare module 'tiddlywiki' { }`, like `global { var $tw: I$TW; }`
+
+And add `import './xxx';` in the `index.d.ts` file.
+
+To rapid prototype the type, just right click a type to open `.d.ts` file in the `node_modules`, and try create new file there, and copy to this repo after a success.

package/package.json

@@ -2,16 +2,45 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.0.4",
+  "version": "0.0.8",
   "url": "https://github.com/tiddly-gittly/tw5-typed",
+  "homepage": "https://github.com/tiddly-gittly/tw5-typed",
+  "bugs": {
+    "url": "https://github.com/tiddly-gittly/tw5-typed/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tiddly-gittly/tw5-typed.git"
+  },
   "types": "src/index.d.ts",
   "files": [
     "src/"
   ],
-  "author": "",
-  "scripts": {},
-  "devDependencies": {
-    "typescript": "^4.5.5"
+  "scripts": {
+    "prepublishOnly": "npx tsc --noEmit"
   },
-  "dependencies": {}
+  "devDependencies": {
+    "@typescript-eslint/eslint-plugin": "5.10.2",
+    "@typescript-eslint/parser": "5.10.2",
+    "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",
+    "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,40 +1,42 @@
-export type SourceIterator = (tiddler: Object, 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, 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;
-  /** (default) treats search string as a list of tokens, and matches if all tokens are found, regardless of adjacency or ordering */
-  words?: boolean;
-}
+declare module 'tiddlywiki' {
+  export type SourceIterator = (tiddler: Tiddler, title: string) => void;
+  export interface ISearchOptions {
+    /** 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;
-  /** 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;
-  /** (optional) a string containing a single exclamation mark if the filter operator is to be negated; */
-  prefix?: 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;
+  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[][];
+  }
 }

package/src/index.d.ts

@@ -1,11 +1,6 @@
-import { I$TW } from './tw';
-export * from './tw';
-export * from './filter-operator';
+import './tw';
+import './filter-operator';
 
-declare module 'tiddlywiki' {}
-
-declare module '@tiddlygit/tiddlywiki' {}
-
-declare global {
-  var $tw: I$TW;
+declare module '@tiddlygit/tiddlywiki' {
+  export * from 'tiddlywiki';
 }

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/tw.d.ts

@@ -1,49 +1,78 @@
-export interface ITiddler {
-  cache: ITiddlerCache;
-  fields: ITiddlerFields;
-}
+declare module 'tiddlywiki' {
+  export interface IBootFilesIndexItem {
+    filepath: string;
+    hasMetaFile: boolean;
+    tiddlerTitle: string;
+    type: string;
+  }
+  /**
+   * Record<tiddlerTitle, IBootFilesIndexItem>
+   */
+  export type IBootFilesIndex = Partial<Record<string, IBootFilesIndexItem>>;
 
-export interface ITiddlerFields {
-  created: string;
-  list: string[];
-  modified: string;
-  tags: string[];
-  text: string;
-  title: string;
-  type: string;
-  [anyKey: string]: unknown;
-}
+  export interface IPluginInfo {
+    tiddlers: ITiddlerFields[];
+  }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface ITiddlerCache {}
-
-/**
- * filepath: '/Users/linonetwo/xxxx/wiki/Meme-of-LinOnetwo/tiddlers/tiddlerTitle.tid',
- * hasMetaFile: false
- * tiddlerTitle: string,
- * type: 'application/x-tiddler',
- */
-export interface IBootFilesIndexItem {
-  filepath: string;
-  hasMetaFile: boolean;
-  tiddlerTitle: string;
-  type: string;
-}
-/**
- * Record<tiddlerTitle, IBootFilesIndexItem>
- */
-export type IBootFilesIndex = Partial<Record<string, IBootFilesIndexItem>>;
-
-export interface I$TW {
-  boot: { argv: string[]; files: IBootFilesIndex; startup: (options: { callback?: () => unknown }) => void };
-  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: Record<string, any>;
+  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: {
+        readBrowserTiddlers: boolean;
+        trapErrors: boolean;
+      };
+    };
+
+    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;
+
+    /** 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: 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>>;
+
+    utils: ITWUtils;
+
+    version: string;
+
+    wiki: Wiki;
+  }
+
+  export declare function TiddlyWiki($tw: object): ITiddlyWiki;
+
+  global {
+    const $tw: ITiddlyWiki;
+  }
 }
-export function TiddlyWiki(): I$TW;

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

@@ -0,0 +1,12 @@
+// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+declare class variablesConstructor {}
+
+export class Widget {
+  constructor(parseTreeNode: unknown, options: unknown);
+  initialize: (parseTreeNode: unknown, options: unknown) => void;
+  parseTreeNode: unknown;
+  wiki: unknown;
+  parentWidget?: Widget;
+  variablesConstructor: variablesConstructor;
+  variables: unknown;
+}