tw5-typed 0.2.16 → 0.2.18

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2021 Tiddly Gittly
+Copyright (c) 2023 Tiddly Gittly
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/package.json

@@ -2,7 +2,7 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.2.16",
+  "version": "0.2.18",
   "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"
@@ -35,10 +32,16 @@
   "devDependencies": {
     "@modern-js/eslint-config": "latest",
     "@modern-js/tsconfig": "latest",
+    "@types/codemirror": "^5.60.6",
+    "@types/echarts": "^4.9.16",
     "@types/node": "^18.11.9",
     "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/boot/config.d.ts

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

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

@@ -0,0 +1,140 @@
+/// <reference path="hooks.d.ts" />
+/// <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" />
+/// <reference path="plugins/index.d.ts" />
+
+declare module 'tiddlywiki' {
+  export interface IPluginInfo {
+    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 type IWikiInfo = Record<string, unknown>;
+
+  export interface ITiddlyWiki {
+    Wiki: typeof Wiki;
+    Story: typeof Story;
+    Tiddler: typeof Tiddler;
+
+    wiki: Wiki;
+    boot: IBoot;
+    crypto: Crypto;
+    utils: IUtils;
+    version: string;
+    safeMode: boolean;
+    config: IConfig;
+    rootWidget: Widget;
+    notifier: Notifier;
+    language: ILanguage;
+    modules: IModules;
+    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: IHooks;
+
+    addUnloadTask(task: any);
+
+    /** Convenience function for pushing a tiddler onto the preloading array */
+    preloadTiddler(fields: Record<string, unknown>);
+    /** 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;
+        bada?: boolean;
+        blackberry?: boolean;
+        chrome?: boolean;
+        firefox?: boolean;
+        firefoxos?: boolean;
+        gecko?: boolean;
+        ios?: boolean;
+        ipad?: boolean;
+        iphone?: boolean;
+        mobile?: boolean;
+        name?: boolean;
+        opera?: boolean;
+        phantomjs?: boolean;
+        safari?: boolean;
+        sailfish?: boolean;
+        seamonkey?: boolean;
+        silk?: boolean;
+        tizen?: boolean;
+        version?: boolean;
+        webkit?: boolean;
+        webos?: boolean;
+        windowsphone?: boolean;
+      };
+      /**
+       * @deprecated
+       * Install `$:/plugins/tiddlywiki/browser-sniff` to use `browser.is`
+       */
+      isFirefox: boolean;
+      /**
+       * @deprecated
+       * Install `$:/plugins/tiddlywiki/browser-sniff` to use `browser.is`
+       */
+      isIE: boolean;
+    };
+    /** NodeJS features, if tw isn't running on a NodeJS environment, the value will be `null` */
+    node: null | Record<string, any>;
+    /** Broswer features, if tw isn't running on a browser environment, the value will be `null` */
+    nodeWebKit: null | Record<string, any>;
+  }
+}

package/src/hooks.d.ts

@@ -0,0 +1,83 @@
+declare module 'tiddlywiki' {
+  interface IHooks {
+    names: Record<string, Function[]>;
+    /** Add hooks to the hashmap */
+    addHook(
+      hookName: 'th-server-command-post-start',
+      callback: (
+        server: unknown,
+        nodeServer: Server,
+        who: 'tiddlywiki',
+      ) => void,
+    );
+    addHook(
+      hookName: 'th-saving-tiddler',
+      callback: (toTiddler: Tiddler, fromTiddler: Tiddler) => Tiddler | void,
+    );
+    addHook(
+      hookName: 'th-renaming-tiddler',
+      callback: (toTiddler: Tiddler, fromTiddler: Tiddler) => Tiddler | void,
+    );
+    addHook(
+      hookName: 'th-relinking-tiddler',
+      callback: (toTiddler: Tiddler, fromTiddler: Tiddler) => Tiddler | void,
+    );
+    addHook(
+      hookName: 'th-importing-tiddler',
+      callback: (tiddler: Tiddler) => Tiddler | void,
+    );
+    addHook(
+      hookName: 'th-before-importing',
+      callback: (tiddler: Tiddler) => Tiddler | void,
+    );
+    addHook(
+      hookName: 'th-opening-default-tiddlers-list',
+      callback: (storyList: string[]) => string[],
+    );
+    addHook(
+      hookName: 'th-make-tiddler-path',
+      callback: (fullPath: string, fullPath: string) => string,
+    );
+    addHook(
+      hookName: 'th-rendering-element',
+      callback: (
+        parseTreeNodes: IParseTreeNode | null,
+        widget: Widget,
+      ) => parseTreeNodes,
+    );
+    addHook(hookName: 'th-navigating', callback: (event: unknown) => unknown);
+    addHook(
+      hookName: 'th-closing-tiddler',
+      callback: (event: unknown) => unknown,
+    );
+    addHook(
+      hookName: 'th-editing-tiddler',
+      callback: (event: unknown) => unknown,
+    );
+    addHook(
+      hookName: 'th-cancelling-tiddler',
+      callback: (event: unknown) => unknown,
+    );
+    addHook(hookName: 'th-new-tiddler', callback: (event: unknown) => unknown);
+    addHook(hookName: 'th-deleting-tiddler', callback: (title: string) => void);
+    addHook(hookName: 'th-page-refreshed', callback: () => void);
+    addHook(hookName: 'th-boot-tiddlers-loaded', callback: () => void);
+    addHook(hookName: 'th-page-refreshed', callback: () => void);
+    addHook(hookName: 'th-page-refreshing', callback: () => void);
+    addHook(hookName: 'th-page-refreshed', callback: () => void);
+    addHook(
+      hookName: 'th-importing-file',
+      callback: (props: {
+        file: unknown;
+        type: string;
+        isBinary: boolean;
+        callback: Function;
+      }) => boolean | void,
+    );
+    addHook(hookName: string, callback: (...arguments_: unknown[]) => unknown);
+    /**
+     * Invoke the hook by key
+     */
+    invokeHook(hookName: string, event: IWidgetEvent): undefined | IWidgetEvent;
+  }
+}

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,11 @@
+/// <reference path="wiki.d.ts" />
+/// <reference path="story.d.ts" />
+/// <reference path="utils/index.d.ts" />
+/// <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;
@@ -13,7 +21,7 @@ declare module 'tiddlywiki' {
     (title: string): ITWModuleExports;
     readonly main: NodeJS.Module | { TiddlyWiki: TW5InitFunction };
   }
-  export interface IModuleSandbox {
+  export interface IEvalContent {
     $tw: ITiddlyWiki;
     // eslint-disable-next-line node/prefer-global/buffer
     Buffer?: Buffer;
@@ -32,6 +40,9 @@ declare module 'tiddlywiki' {
     exports: ITWModuleExports,
     requireFunction: ITWRequire,
   ) => void;
+
+  export type ITWModules = IModules;
+
   /**
    * Information about each module is kept in an object with these members:
    *
@@ -47,7 +58,7 @@ declare module 'tiddlywiki' {
    *
    * 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 {
+  interface IModules {
     /** Apply the exports of the modules of a particular type to a target object */
     applyMethods: (
       moduleType: string,

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

@@ -0,0 +1,56 @@
+declare module 'tiddlywiki' {
+  declare class Story {
+    wiki: Wiki;
+    storyTitle: string;
+    historyTitle: string;
+
+    constructor(options: {
+      wiki?: Wiki;
+      storyTitle?: string;
+      historyTitle?: string;
+    });
+
+    getStoryList(): string[];
+
+    navigateTiddler(
+      navigateTo: string,
+      navigateFromTitle: string,
+      navigateFromClientRect: DOMRect,
+    );
+
+    addToStory(
+      navigateTo: string,
+      navigateFromTitle: string,
+      options?: {
+        openLinkFromInsideRiver?: 'top' | 'bottom' | 'above' | 'below';
+      },
+    );
+
+    addToHistory(
+      navigateTo: string | string[],
+      navigateFromClientRect: DOMRect,
+    );
+
+    saveStoryList(storyList: string[] | string);
+
+    storyCloseTiddler(targetTitle: string);
+
+    storyCloseAllTiddlers();
+
+    storyCloseOtherTiddlers(targetTitle: string);
+
+    storyEditTiddler(targetTitle: string);
+
+    storyDeleteTiddler(targetTitle: string);
+
+    storySaveTiddler(targetTitle: string);
+
+    storyCancelTiddler(targetTitle: string);
+
+    storyNewTiddler(targetTitle: string);
+  }
+}
+
+declare module '$:/core/modules/story.js' {
+  export { Story } from 'tiddlywiki';
+}

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

@@ -0,0 +1,51 @@
+declare const addClass: (element: Element, className: string) => void;
+declare const addEventListeners: (
+  domNode: Node,
+  events: {
+    handlerFunction?: (event: MouseEvent) => void;
+    handlerMethod?: string;
+    handlerObject?: Widget;
+    name: string;
+  }[],
+) => void;
+
+declare class Notifier {
+  /**
+   * Display a notification
+   * * title: Title of tiddler containing the notification text
+   * * options: see below
+   * Options include:
+   */
+  display(title: string, options?: Record<string, unknown>): void;
+}
+
+declare module 'tiddlywiki' {
+  interface IUtils {
+    /**
+     * Alternative to `element.classList.add`, add a css class name to an element, see issue for detail.
+     * @link https://github.com/Jermolene/TiddlyWiki5/issues/6475
+     * @param element
+     * @param className
+     */
+    addClass: typeof addClass;
+    /**
+     * Attach specified event handlers to a DOM node
+     * @param domNode: where to attach the event handlers
+     * @param events: array of event handlers to be added (see below)
+     * Each entry in the events array is an object with these properties:
+     * * name: event name of `addEventListener`
+     * * handlerFunction: optional event handler function
+     * * handlerObject: optional event handler object
+     * * handlerMethod: optionally specifies object handler method name (defaults to `handleEvent`)
+     */
+    addEventListeners: typeof addEventListeners;
+    /**
+     * Notifier mechanism
+     */
+    Notifier: typeof Notifier;
+  }
+}
+
+declare module '$:/core/modules/utils/dom.js' {
+  export { addClass, addEventListeners, Notifier };
+}

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

@@ -0,0 +1,33 @@
+declare const generateTiddlerFilepath: (
+  title: string,
+  options?: {
+    directory?: string;
+    extension?: string;
+    fileInfo?: {
+      originalpath?: string;
+      filePath?: string;
+      writeError?: boolean;
+    };
+    pathFilters?: string[];
+    wiki?: Wiki;
+  },
+) => string;
+
+declare module 'tiddlywiki' {
+  interface IUtils {
+    /**
+     * Generate the filepath for saving a tiddler
+     * Options include:
+     * * extension: file extension to be added the finished filepath
+     * * directory: absolute path of root directory to which we are saving
+     * * pathFilters: optional array of filters to be used to generate the base path
+     * * wiki: optional wiki for evaluating the pathFilters
+     * * fileInfo: an existing fileInfo object to check against
+     */
+    generateTiddlerFilepath: typeof generateTiddlerFilepath;
+  }
+}
+
+declare module '$:/core/modules/utils/utils.js' {
+  export { generateTiddlerFilepath };
+}

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

@@ -0,0 +1,3 @@
+/// <reference path="dom.d.ts" />
+/// <reference path="utils.d.ts" />
+/// <reference path="filesystem.d.ts" /> 

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

@@ -0,0 +1,25 @@
+declare const count: (object: object) => number;
+declare const hashString: (str: string) => number;
+declare const formatDateString: (date: Date, format: string) => string;
+
+declare module 'tiddlywiki' {
+  interface IUtils {
+    /**
+     * @en
+     * Return the number of keys in an object
+     * @zh
+     * 返回一个对象中的键的数量
+     */
+    count: typeof count;
+    /** the function behind `<<now "format">> */
+    formatDateString: typeof formatDateString;
+    /** Hash a string to a number
+     * Derived from http://stackoverflow.com/a/15710692
+     */
+    hashString: typeof hashString;
+  }
+}
+
+declare module '$:/core/modules/utils/utils.js' {
+  export { count, formatDateString, hashString };
+}