tw5-typed 0.2.16 → 0.2.17

package/package.json

@@ -2,7 +2,7 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.2.16",
+  "version": "0.2.17",
   "url": "https://github.com/tiddly-gittly/tw5-typed",
   "homepage": "https://github.com/tiddly-gittly/tw5-typed",
   "bugs": {
@@ -16,9 +16,6 @@
   "files": [
     "src/"
   ],
-  "scripts": {
-    "check": "tsc --noEmit && eslint src/**/*.ts"
-  },
   "husky": {
     "hooks": {
       "pre-commit": "lint-staged"
@@ -39,6 +36,10 @@
     "husky": "^8.0.2",
     "lint-staged": "^13.1.0",
     "rimraf": "^3.0.2",
+    "tiddlywiki": "^5.2.5",
     "typescript": "^4.9.4"
+  },
+  "scripts": {
+    "check": "tsc --noEmit && eslint src/**/*.ts"
   }
-}
+}

package/src/{twconfig.d.ts → boot/config.d.ts}

@@ -1,4 +1,15 @@
 declare module 'tiddlywiki' {
+  export interface IContentTypeInfo {
+    deserializerType: string;
+    encoding: string;
+    extension: string;
+    flags: string[];
+  }
+
+  export interface IFileExtensionInfo {
+    type: string;
+  }
+
   interface ITWConfig {
     [configName: string]: unknown;
     /** Map type to file content type */

package/src/boot/index.d.ts

@@ -0,0 +1,32 @@
+/// <reference path="config.d.ts" />
+
+declare module 'tiddlywiki' {
+  export interface IBootFilesIndexItem {
+    filepath: string;
+    hasMetaFile: boolean;
+    tiddlerTitle: string;
+    type: string;
+  }
+
+  export type IBootFilesIndex = Record<string, IBootFilesIndexItem>;
+
+  export interface IStartUpOption {
+    bootPath?: string;
+    callback?: () => unknown;
+  }
+
+  export interface IBoot {
+    argv: string[];
+    boot: (callback?: () => void) => void;
+    files: IBootFilesIndex;
+    log: (logString: string) => void;
+    logMessages: string[];
+    startup: (options: IStartUpOption) => void;
+    /** Default boot tasks */
+    tasks: {
+      readBrowserTiddlers: boolean;
+      trapErrors: boolean;
+    };
+    excludeRegExp: RegExp;
+  }
+}

package/src/{tw.d.ts → core.d.ts}

@@ -1,73 +1,117 @@
-/// <reference path="filter-operator.d.ts" />
-/// <reference path="modules.d.ts" />
-/// <reference path="Tiddler.d.ts" />
-/// <reference path="twconfig.d.ts" />
-/// <reference path="utils.d.ts" />
-/// <reference path="Widget.d.ts" />
-/// <reference path="Wiki.d.ts" />
-/// <reference path="parser.d.ts" />
-/// <reference path="ast.d.ts" />
-
-import { Server } from 'http';
+/// <reference path="boot/index.d.ts" />
+/// <reference path="wiki/index.d.ts" />
+/// <reference path="utils/index.d.ts" />
+/// <reference path="tiddler/index.d.ts" />
+/// <reference path="modules/index.d.ts" />
 
 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 IPluginInfo {
-    tiddlers: ITiddlerFields[];
-  }
-
-  export interface IFileExtensionInfo {
-    type: string;
+    version: string;
+    'plugin-type': string;
+    dependents: string;
+    type: 'application/json';
+    text: string;
+    [pluginProperty: string]: string;
   }
 
   export interface ILanguage {
-    getString: (
-      key: string,
-      options: { variables: { title: string } },
-    ) => string;
-  }
-
-  export interface IContentTypeInfo {
-    deserializerType: string;
-    encoding: string;
-    extension: string;
-    flags: string[];
+    getString(key: string, options: { variables: { title: string } }): string;
   }
 
-  export interface IStartUpOption {
-    bootPath?: string;
-    callback?: () => unknown;
-  }
+  export type IWikiInfo = Record<string, unknown>;
 
   export interface ITiddlyWiki {
-    Tiddler: typeof Tiddler;
     Wiki: typeof Wiki;
+    Tiddler: typeof Tiddler;
 
-    boot: {
-      argv: string[];
-      boot: (callback?: () => void) => void;
-      files: IBootFilesIndex;
-      log: (logString: string) => void;
-      logMessages: string[];
-      startup: (options: IStartUpOption) => void;
-      /** Default boot tasks */
-      tasks: {
-        readBrowserTiddlers: boolean;
-        trapErrors: boolean;
-      };
-      excludeRegExp: RegExp;
+    wiki: Wiki;
+    boot: IBoot;
+    crypto: Crypto;
+    utils: ITWUtils;
+    version: string;
+    safeMode: boolean;
+    config: ITWConfig;
+    rootWidget: Widget;
+    notifier: Notifier;
+    language: ILanguage;
+    modules: ITWModules;
+    locationHash: string;
+    passwordPrompt: PasswordPrompt;
+    packageInfo: Record<string, unknown>;
+
+    /**
+     * Check for this window being the source of the drag. If true, some drop target widget will stop responding to the drop event, so you can handle drop event in your own widget.
+     * Used by `DropZoneWidget.prototype.handleDropEvent`
+     */
+    dragInProgress?: boolean;
+
+    /**
+      Global Hooks mechanism which allows plugins to modify default functionality
+    */
+    hooks: {
+      names: Record<string, any>;
+      /**
+        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;
+      /**
+        Invoke the hook by key
+      */
+      invokeHook(
+        hookName: string,
+        event: IWidgetEvent,
+      ): undefined | IWidgetEvent;
     };
 
+    addUnloadTask(task: any): void;
+
+    /** 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>>;
+
+    getLibraryItemSearchPaths(libraryPath: string, envVar?: string): string;
+    findLibraryItem(name: string, paths: string[]): string | null;
+    loadPluginFolder(
+      filepath: string,
+      excludeRegExp?: RegExp,
+    ): IPluginInfo | null;
+    loadPlugin(name: string, paths: string[]): void;
+    loadPlugins(plugins: string[], libraryPath: string, envVar?: string): void;
+    loadWikiTiddlers(
+      wikiPath: string,
+      options?: { parentPaths?: string; readOnly?: boolean },
+    ): IWikiInfo;
+    loadTiddlersNode(): void;
+    loadTiddlersBrowser(): void;
+    loadTiddlersFromFile(
+      filepath: string,
+      defaultFields?: Record<string, unknown>,
+    ): {
+      filepath: string;
+      type: string;
+      tiddlers: ITiddlerFields[];
+      hasMetaFile: boolean;
+    };
+    loadMetadataForFile(filepath: string): ITiddlerFields | null;
+    loadTiddlersFromPath(
+      filepath: string,
+      excludeRegExp?: RegExp,
+    ): ITiddlerFields[];
+    loadTiddlersFromSpecification(
+      filepath: string,
+      excludeRegExp?: RegExp,
+    ): ITiddlerFields[];
+
     browser: null | {
       is?: {
         android?: boolean;
@@ -105,77 +149,9 @@ declare module 'tiddlywiki' {
        */
       isIE: boolean;
     };
-
-    config: ITWConfig;
-
-    /**
-     * Check for this window being the source of the drag. If true, some drop target widget will stop responding to the drop event, so you can handle drop event in your own widget.
-     * Used by `DropZoneWidget.prototype.handleDropEvent`
-     */
-    dragInProgress?: boolean;
-
-    /**
-      Global Hooks mechanism which allows plugins to modify default functionality
-    */
-    hooks: {
-      /**
-        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;
-      /**
-        Invoke the hook by key
-      */
-      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;
-    language: ILanguage;
-    modules: ITWModules;
-
     /** NodeJS features, if tw isn't running on a NodeJS environment, the value will be `null` */
-    node: null | object;
+    node: null | Record<string, any>;
     /** Broswer features, if tw isn't running on a browser environment, the value will be `null` */
-    nodeWebKit: null | object;
-
-    notifier: Notifier;
-    /** 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>>;
-
-    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;
-    utils: ITWUtils;
-    version: string;
-    wiki: Wiki;
+    nodeWebKit: null | Record<string, any>;
   }
-
-  export type TW5InitFunction = ($tw?: ITiddlyWiki) => ITiddlyWiki;
-  export const TiddlyWiki: TW5InitFunction;
 }

package/src/index.d.ts

@@ -1,19 +1,14 @@
-/// <reference path="tw.d.ts" />
-/// <reference path="server.d.ts" />
+/// <reference path="core.d.ts" />
 
-import * as TW from 'tiddlywiki';
+import { ITiddlyWiki } from 'tiddlywiki';
 
 export * from 'tiddlywiki';
+
+declare module 'tiddlywiki' {
+  export type TW5InitFunction = (baseObject?: Record<string, unknown>) => ITiddlyWiki
+  export const TiddlyWiki: TW5InitFunction;
+}
+
 declare global {
-  const $tw: TW.ITiddlyWiki;
-  // const Buffer: ?Buffer;
-  // const clearInterval: typeof global.clearInterval;
-  // const clearTimeout: typeof global.clearTimeout;
-  // const console: Console;
-  // const exports: TW.ITWModuleExports;
-  // const module: { exports: TW.ITWModuleExports; readonly id: string };
-  // const process: ?NodeJS.Process;
-  // const require: ITWRequire;
-  // const setInterval: typeof global.setInterval;
-  // const setTimeout: typeof global.setTimeout;
+  export let $tw: ITiddlyWiki;
 }

package/src/{modules.d.ts → modules/index.d.ts}

@@ -1,3 +1,8 @@
+/// <reference path="server/index.d.ts" />
+/// <reference path="parsers/index.d.ts" />
+/// <reference path="widgets/index.d.ts" />
+/// <reference path="parsers/index.d.ts" />
+
 declare module 'tiddlywiki' {
   export interface ITWModuleExports {
     [exportName: string]: unknown;

package/src/{ast.d.ts → modules/parsers/index.d.ts}

@@ -1,4 +1,58 @@
 declare module 'tiddlywiki' {
+  export interface IParserOptions {
+    /**
+     * Optional source uri, used in parseText
+     */
+    _canonical_uri?: string;
+    /**
+     * While calling `getCacheForTiddler`, use inlineParseTree or blockParseTree
+     */
+    parseAsInline?: boolean;
+  }
+
+  export class WikiParseRule {
+    is: { block?: boolean; inline?: boolean };
+
+    match?: unknown;
+
+    matchRegExp?: RegExp;
+
+    parser?: WikiParser;
+
+    nextTag?: unknown;
+
+    /** `{type: 'macrocall', start: 261, params: Array(1), name: 'reuse-tiddler', end: 290}` */
+    nextCall?: {
+      end: number;
+      name: string;
+      /** `{ type: 'macro-parameter'; start: 276; value: '快速创建新笔记按钮'; end: 288 }` */
+      params: { end: number; start: number; type: string; value: string };
+      start: number;
+      type: string;
+    };
+  }
+  export class WikiParser {
+    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[];
+  }
+
   export interface IParseTreeAttribute {
     end?: number;
     name?: string;

package/src/{server.d.ts → modules/server/index.d.ts}

@@ -1,5 +1,3 @@
-/// <reference path="Wiki.d.ts" />
-
 import type Http from 'http';
 
 declare module 'tiddlywiki' {

package/src/{Tiddler.d.ts → tiddler/index.d.ts}

@@ -1,31 +1,33 @@
 declare module 'tiddlywiki' {
+  export type ITiddlerCache = Record<string, unknown>;
+
+  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;
+  }
+
   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>);
+
     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;
+    isEqual(tiddler: Tiddler, excludeFields: string[]): boolean;
   }
-
-  // eslint-disable-next-line @typescript-eslint/no-empty-interface
-  export interface ITiddlerCache {}
 }

package/src/{Wiki.d.ts → wiki/index.d.ts}

@@ -1,4 +1,4 @@
-/// <reference path="parser.d.ts" />
+/// <reference path="../modules/filters/index.d.ts" />>
 
 declare module 'tiddlywiki' {
   export interface IMakeWidgetOptions extends IRenderOptions {

package/src/parser.d.ts

@@ -1,57 +0,0 @@
-/// <reference path="ast.d.ts" />
-
-declare module 'tiddlywiki' {
-  export interface IParserOptions {
-    /**
-     * Optional source uri, used in parseText
-     */
-    _canonical_uri?: string;
-    /**
-     * While calling `getCacheForTiddler`, use inlineParseTree or blockParseTree
-     */
-    parseAsInline?: boolean;
-  }
-
-  export class WikiParseRule {
-    is: { block?: boolean; inline?: boolean };
-
-    match?: unknown;
-
-    matchRegExp?: RegExp;
-
-    parser?: WikiParser;
-
-    nextTag?: unknown;
-
-    /** `{type: 'macrocall', start: 261, params: Array(1), name: 'reuse-tiddler', end: 290}` */
-    nextCall?: {
-      end: number;
-      name: string;
-      /** `{ type: 'macro-parameter'; start: 276; value: '快速创建新笔记按钮'; end: 288 }` */
-      params: { end: number; start: number; type: string; value: string };
-      start: number;
-      type: string;
-    };
-  }
-  export class WikiParser {
-    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[];
-  }
-}