tw5-typed 0.0.10 → 0.1.2

package/package.json

@@ -2,7 +2,7 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.0.10",
+  "version": "0.1.2",
   "url": "https://github.com/tiddly-gittly/tw5-typed",
   "homepage": "https://github.com/tiddly-gittly/tw5-typed",
   "bugs": {
@@ -20,6 +20,7 @@
     "prepublishOnly": "npx tsc --noEmit"
   },
   "devDependencies": {
+    "@types/node": "^17.0.18",
     "@typescript-eslint/eslint-plugin": "5.11.0",
     "@typescript-eslint/parser": "5.11.0",
     "eslint": "8.8.0",

package/src/Tiddler.d.ts

@@ -3,7 +3,7 @@ declare module 'tiddlywiki' {
     constructor(...fields: Array<Record<string, unknown> | Tiddler>);
     readonly cache: ITiddlerCache;
     readonly fields: ITiddlerFields;
-    static fieldModules: IModule;
+    static fieldModules: Record<string, IModuleInfo>;
     hasField(field: string): boolean;
     isEqual(tiddler: Tiddler, excludeFields: string[]): boolean;
   }

package/src/Wiki.d.ts

@@ -13,5 +13,38 @@ declare module 'tiddlywiki' {
      * Get full list of tiddler titles in the wiki
      */
     getTiddlers: () => string[];
+    /**
+     * Compile filter string to be a function that execute the filter in the wiki.
+     * You can pass an optional iterator that provide the input to the returned function. If no iterator is provided, filter will use first operator to get input.
+     */
+    compileFilter: (filterString: string) => (iterator?: SourceIterator) => string[];
+    /**
+     * Set JSON tiddler, Object in data field will be JSON.stringify and put into the text.
+     */
+    setTiddlerData: (title: string, data?: object, fields?: ITiddlerFields, options?: any) => void;
+    /**
+     * Create or update tiddler.
+     * Update existed tiddler based on the title field.
+     */
+    addTiddler: (tiddler: Tiddler | ITiddlerFields) => void;
+    /**
+     * Get tiddler's text field, with an optional default text.
+     * If have _is_skinny field, will just return null (this is a rare case, so not put in the return type for now).
+     * 
+     * @param title will return undefined (or fallback) if the tiddler isn't found
+     * @param fallbackText default text when text field is empty or undefined
+     */
+    getTiddlerText(title: string, fallbackText: string): string;
+    getTiddlerText(title: string, fallbackText?: string): string | undefined;
+    /**
+     * Set tiddler text of any field.
+     *
+     * @param {string} title title of tiddler
+     * @param {string} field field name to set
+     * @param {string | undefined} index data index(key) to set, if you are setting a JSON data tiddler. Be `undefined` if you are just setting a normal tiddler's field, this will be most of the case.
+     * @param {string} value text content to set
+     * @param {object} options options, see tiddlywiki dev doc for details
+     */
+    setText: (title: string, field?: string, index?: string | undefined, value?: string, options?: any) => void;
   }
 }

package/src/filter-operator.d.ts

@@ -93,13 +93,13 @@ Either way, we could interpret the `!` flag on the filter, if present, to mean t
 As with [JavaScript Macros](#JavaScript%20Macros), filter operators should not make modifications to tiddlers, but only return a list of tiddlers or a tiddler iterator.
 
    */
-  export type IFilterOperator = (source: (iter: SourceIterator) => void, operator: IFilterOperatorParamOperator) => string[] | ((iter: SourceIterator) => void);
+  export type IFilterOperator = (source: (iter: SourceIterator) => void, operator: IFilterOperatorParameterOperator) => string[] | ((iter: SourceIterator) => void);
 
   /**
    * A [tiddler iterator](#Tiddler%20Iterators) representing the results of the previous filter step (or all tiddlers, if this filter appears first in an expression), conventionally named `source`.
-   * 
+   *
    * For Example, with an iterator over all the tiddlers tagged as `interesting`, use it like this:
-   * 
+   *
    * ```js
    * var result = [];
       var include = true;

package/src/index.d.ts

@@ -1,6 +1,24 @@
-import './tw';
-import './filter-operator';
+/// <reference path="tw.d.ts" />
 
-declare module '@tiddlygit/tiddlywiki' {
-  export * from 'tiddlywiki';
+export * from 'tiddlywiki';
+
+import * as TW from 'tiddlywiki';
+
+import '@types/node';
+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;
+}
+
+declare module '@types/tiddlywiki' {
+  export const TiddlyWiki: TW.TW5InitFunction;
 }

package/src/modules.d.ts

@@ -1,6 +1,6 @@
 declare module 'tiddlywiki' {
   export interface ITWModuleExports {
-    [exportName: unknown]: unknown;
+    [exportName: string]: unknown;
     name?: string;
     type?: string;
   }
@@ -11,7 +11,7 @@ declare module 'tiddlywiki' {
   }
   export interface ITWRequire {
     (title: string): ITWModuleExports;
-    readonly main: NodeJS.Module | { TiddlyWiki: typeof TiddlyWiki };
+    readonly main: NodeJS.Module | { TiddlyWiki: TW5InitFunction };
   }
   export interface IModuleSandbox {
     $tw: ITiddlyWiki;

package/src/tw.d.ts

@@ -1,4 +1,10 @@
-import { Widget } from './widget'
+/// <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" />
 
 declare module 'tiddlywiki' {
   export interface IBootFilesIndexItem {
@@ -65,19 +71,13 @@ declare module 'tiddlywiki' {
     /** External JavaScript can populate this array before calling boot.js in order to preload tiddlers */
     preloadTiddlers: Record<string, Record<string, unknown>>;
 
+    rootWidget: Widget;
+
     utils: ITWUtils;
 
     version: string;
-
     wiki: Wiki;
-    rootWidget: Widget;
   }
 
-  export function TiddlyWiki($tw: object): ITiddlyWiki;
-}
-
-import { ITiddlyWiki } from 'tiddlywiki';
-declare global {
-  const $tw: ITiddlyWiki;
+  export type TW5InitFunction = ($tw?: ITiddlyWiki) => ITiddlyWiki;
 }
-export {}

package/src/twconfig.d.ts

@@ -1,5 +1,5 @@
 declare module 'tiddlywiki' {
-  declare interface ITWConfig {
+  interface ITWConfig {
     [configName: string]: unknown;
     /** Map type to file content type */
     contentTypeInfo: Record<string, IContentTypeInfo>;

package/src/utils.d.ts

@@ -1,8 +1,11 @@
+/// <reference path="Crypto.d.ts" />
+/// <reference path="PasswordPrompt.d.ts" />
+
 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 {
+  export 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 */

package/src/widget.d.ts

@@ -1,37 +1,41 @@
-// eslint-disable-next-line @typescript-eslint/no-extraneous-class
-declare class variablesConstructor {}
+declare module 'tiddlywiki' {
+  // eslint-disable-next-line @typescript-eslint/no-extraneous-class
+  class variablesConstructor {}
 
-export declare class Widget {
-  constructor(parseTreeNode: unknown, options: unknown);
-  initialize: (parseTreeNode: unknown, options: unknown) => void;
-  parseTreeNode: unknown;
-  wiki: unknown;
-  parentWidget?: Widget;
-  variablesConstructor: variablesConstructor;
-  variables: unknown;
-  domNodes: Node[];
-  /**
+  export class Widget {
+    constructor(parseTreeNode: unknown, options: unknown);
+    initialize: (parseTreeNode: unknown, options: unknown) => void;
+    parseTreeNode: unknown;
+    wiki: unknown;
+    parentWidget?: Widget;
+    variablesConstructor: variablesConstructor;
+    variables: unknown;
+    domNodes: Node[];
+    /**
     Add an event listener
   */
-  addEventListener(type: string, handler: (args: any[]) => void): void;
-  /**
+    addEventListener(type: string, handler: (arguments_: unknown[]) => void): void;
+    /**
     Dispatch an event to a widget. If the widget doesn't handle the event then it is also dispatched to the parent widget
   */
-  dispatchEvent(type: string): void;
-  /**
+    dispatchEvent(type: string): void;
+    /**
     Add a list of event listeners from an array [{type:,handler:},...]
   */
-  addEventListeners(listeners: { type: string; handler: (args: any[]) => void }[]): void;
+    addEventListeners(listeners: Array<{ handler: (arguments_: unknown[]) => void; type: string }>): void;
 
-  parentDomNode: Node;
-  execute: () => void;
+    parentDomNode: Node;
+    execute: () => void;
 
-  /**
-   * Lifecycle method: Render this widget into the DOM
-   */
-  render(parent: Node, nextSibling: Node): void;
-  computeAttributes(): void;
-}
-declare module 'tiddlywiki' {
-  export type Widget = typeof Widget;
+    /**
+     * Lifecycle method: Render this widget into the DOM
+     */
+    render(parent: Node, nextSibling: Node): void;
+    computeAttributes(): void;
+    /**
+     * Get parameters that user set in the widget
+     * @param name attribute name, for example, `actions` in the button widget
+     */
+    getAttribute(name: string): string;
+  }
 }

package/src/tiddlywiki-test.ts

@@ -1,17 +0,0 @@
-import { Widget as IWidget } from 'tiddlywiki'
-
-const Widget = {} as unknown as IWidget;
-export class ReactWidget extends Widget {
-  constructor(parseTreeNode: any, options: any) {
-    super(parseTreeNode, options);
-  }
-
-  render(parent: Node, nextSibling: Node) {
-    this.parentDomNode = parent;
-    this.execute();
-    this.computeAttributes();
-    const containerElement = document.createElement('div');
-    this.domNodes.push(containerElement);
-    parent.appendChild(containerElement);
-  }
-}