tw5-typed 0.0.6 → 0.0.7

package/README.md

@@ -26,8 +26,24 @@ Then you will have global types like `$tw` automatically. You can import the res
 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.
@@ -35,3 +51,5 @@ You can add new `*.d.ts` file to contain 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,39 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "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": {},
+  "scripts": {
+    "prepublishOnly": "npx tsc --noEmit"
+  },
   "devDependencies": {
-    "typescript": "^4.5.5"
+    "@typescript-eslint/eslint-plugin": "5.10.2",
+    "@typescript-eslint/parser": "5.10.2",
+    "typescript": "4.5.5",
+    "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-import": "2.25.4",
+    "eslint-plugin-node": "11.1.0",
+    "eslint-plugin-prettier": "4.0.0",
+    "eslint-plugin-typescript-sort-keys": "2.1.0",
+    "eslint-plugin-unicorn": "40.1.0",
+    "prettier": "2.5.1"
   },
   "dependencies": {}
 }

package/src/tw.d.ts

@@ -1,18 +1,23 @@
 declare module 'tiddlywiki' {
   export interface ITiddler {
-    cache: ITiddlerCache;
-    fields: ITiddlerFields;
+    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 {
-    created: string;
-    list: string[];
-    modified: string;
-    tags: string[];
-    text: string;
-    title: string;
-    type: string;
-    [anyKey: string]: unknown;
+    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
@@ -35,9 +40,71 @@ declare module 'tiddlywiki' {
    */
   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 };
+  export interface IModule {
+    moduleType: string;
+    definition: unknown;
+    exports: object | null;
+  }
+
+  export interface TiddlyWiki {
+    boot: {
+      argv: string[];
+      files: IBootFilesIndex;
+      startup(options: { callback?: () => unknown }): void;
+      /** Default boot tasks */
+      tasks: {
+        trapErrors: boolean;
+        readBrowserTiddlers: 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;
+    /** NodeJS features, if tw isn't running on a NodeJS environment, the value will be `null` */
+    node: null | object;
+    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;
+
+    hooks: {
+      addHook: (hookName: string, callback: (...arguments_: any[]) => unknown) => void;
+    };
     wiki: {
       getTiddler: (title: string) => ITiddler | undefined;
       /**
@@ -45,11 +112,75 @@ declare module 'tiddlywiki' {
        */
       getTiddlers: () => string[];
     };
-    utils: Record<string, any>;
+    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;
+    };
   }
-  export function TiddlyWiki(): I$TW;
+
+  export function TiddlyWiki(): TiddlyWiki;
 
   global {
-    var $tw: I$TW;
+    const $tw: TiddlyWiki;
   }
 }

package/src/widget.d.ts

@@ -0,0 +1,13 @@
+declare class variablesConstructor {
+
+}
+
+export class Widget {
+  constructor(parseTreeNode: any, options: any);
+  initialize: (parseTreeNode: any, options: any) => void;
+  parseTreeNode: any;
+  wiki: any;
+  parentWidget?: Widget;
+  variablesConstructor: variablesConstructor;
+  variables: any;
+}