tw5-typed 0.0.3 → 0.0.7

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,39 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.0.3",
+  "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/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: 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;
+  }
 
-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 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;
+  }
 }

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

@@ -1,45 +1,186 @@
-export interface ITiddler {
-  cache: ITiddlerCache;
-  fields: ITiddlerFields;
-}
+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 {
-  created: string;
-  list: string[];
-  modified: string;
-  tags: string[];
-  text: string;
-  title: string;
-  type: string;
-}
+  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 {}
-
-/**
- * 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;
-    getTiddlers: () => ITiddler[];
-  };
-  utils: Record<string, any>;
+  // 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 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;
+      /**
+       * 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;
+    };
+  }
+
+  export function TiddlyWiki(): TiddlyWiki;
+
+  global {
+    const $tw: TiddlyWiki;
+  }
 }
-export function TiddlyWiki(): I$TW;

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;
+}