tw5-typed 0.3.1 → 0.3.3

package/package.json

@@ -2,7 +2,7 @@
   "description": "Types for tiddlywiki",
   "license": "MIT",
   "name": "tw5-typed",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "url": "https://github.com/tiddly-gittly/tw5-typed",
   "homepage": "https://github.com/tiddly-gittly/tw5-typed",
   "bugs": {

package/src/boot/index.d.ts

@@ -4,10 +4,13 @@ declare module 'tiddlywiki' {
   export interface IBootFilesIndexItem {
     filepath: string;
     hasMetaFile: boolean;
-    tiddlerTitle: string;
+    isEditableFile: boolean;
     type: string;
   }
 
+  /**
+   * Key is `tiddlerTitle: string;`
+   */
   export type IBootFilesIndex = Record<string, IBootFilesIndexItem>;
 
   export interface IStartUpOption {

package/src/core.d.ts

@@ -82,12 +82,7 @@ declare module 'tiddlywiki' {
     loadTiddlersFromFile(
       filepath: string,
       defaultFields?: Record<string, unknown>,
-    ): {
-      filepath: string;
-      type: string;
-      tiddlers: ITiddlerFields[];
-      hasMetaFile: boolean;
-    };
+    ): ITiddlersInFile;
     loadMetadataForFile(filepath: string): ITiddlerFields | null;
     loadTiddlersFromPath(
       filepath: string,

package/src/modules/index.d.ts

@@ -6,6 +6,7 @@
 /// <reference path="widgets/index.d.ts" />
 /// <reference path="parsers/index.d.ts" />
 /// <reference path="syncer/syncAdaptor.d.ts" />
+/// <reference path="syncer/syncer.d.ts" />
 
 declare module 'tiddlywiki' {
   export interface ITWModuleExports {

package/src/modules/syncer/syncAdaptor.d.ts

@@ -1,5 +1,9 @@
 declare module 'tiddlywiki' {
-  export abstract class SyncAdaptor {
+  /**
+   * SyncAdaptorModules
+   * @url https://tiddlywiki.com/dev/#SyncAdaptorModules
+   */
+  export interface SyncAdaptor {
     name: string;
     supportsLazyLoading: boolean;
     isReady(): boolean;
@@ -8,6 +12,29 @@ declare module 'tiddlywiki' {
       title: string,
       callback: (error: null, fileInfo: IFileInfo) => void,
     ): void;
+    /**
+     * Retrieves the titles of tiddlers that need to be updated from the server.
+
+      This method is optional. If an adaptor doesn't implement it then synchronisation will be unidirectional from the TiddlyWiki store to the adaptor, but not the other way.
+
+      The syncer will use the `getUpdatedTiddlers()` method in preference to the `getSkinnyTiddlers()` method.
+
+      |!Parameter |!Description |
+      |syncer |Reference to the syncer object making the call |
+      |callback |Callback function invoked with parameter `err,data` -- see below |
+
+      The data provided by the callback is as follows:
+
+      ```
+      {
+      modifications: [<array of title>],
+      deletions: [<array of title>],
+      }
+      ```
+     * @param syncer 
+     * @param callback 
+     */
+    getUpdatedTiddlers(syncer: Syncer,callback: (error: Error | null | undefined, changes: { modifications: string[]; deletions: string[] }) => void): void;
     wiki: Wiki;
   }
 }

package/src/modules/syncer/syncer.d.ts

@@ -0,0 +1,9 @@
+declare module 'tiddlywiki' {
+  export class Syncer {
+    syncadaptor?: SyncAdaptor;
+    /**
+      Synchronise from the server by reading the skinny tiddler list and queuing up loads for any tiddlers that we don't already have up to date
+    */
+    syncFromServer(): void;
+  }
+}

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

@@ -37,6 +37,12 @@ declare module 'tiddlywiki' {
     encoding: string;
     filepath: string;
   }
+  export interface ITiddlersInFile {
+    filepath: string;
+    type: string;
+    tiddlers: ITiddlerFields[];
+    hasMetaFile: boolean;
+  }
   interface IUtils {
     /**
      * Generate the filepath for saving a tiddler

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

@@ -2,3 +2,4 @@
 /// <reference path="utils.d.ts" />
 /// <reference path="fakedom.d.ts" />
 /// <reference path="filesystem.d.ts" />
+/// <reference path="logger.d.ts" />

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

@@ -0,0 +1,23 @@
+declare module 'tiddlywiki' {
+  export class Logger {
+    new (): Logger;
+    setSaveBuffer(logger: Logger): void;
+    /**
+      Log a message
+    */
+    log: typeof console.log;
+    clearAlerts(): void;
+    getBuffer(): string;
+    table: typeof console.table;
+    /**
+      Alert a message
+    */
+    alert(...args: any[]): void;
+  }
+  interface IUtils {
+    /**
+     * A basic logging implementation
+     */
+    Logger: Logger;
+  }
+}

package/src/tiddler/index.d.ts

@@ -30,12 +30,20 @@ declare module 'tiddlywiki' {
     hasField(): boolean;
     isPlugin(): boolean;
     isDraft(): boolean;
-    getFieldStrings(field: string, defaultValue: string): string;
+    /**
+     * Stringify the field with the associated tiddler field module (if any)
+     */
+    getFieldString(field: string, defaultValue?: string): string;
+    /**
+      Get all the fields as a hashmap of strings. Options:
+      exclude: an array of field names to exclude
+    */
+    getFieldStrings(field: string, defaultValue?: string): string;
     getFieldDay(field: string): string;
     /**
       Get the value of a field as a list
     */
-    getFieldList(field: string, defaultValue: string): string[];
+    getFieldList(field: string, defaultValue?: string): string[];
     /**
     Get all the fields as a name:value block.
     @param options:
@@ -43,6 +51,6 @@ declare module 'tiddlywiki' {
     */
     getFieldStringBlock(options: { exclude?: string[] }): string;
 
-    isEqual(tiddler: Tiddler, excludeFields: string[]): boolean;
+    isEqual(tiddler: Tiddler, excludeFields?: string[]): boolean;
   }
 }

package/src/wiki/index.d.ts

@@ -67,7 +67,10 @@ declare module 'tiddlywiki' {
      */
     compileFilter(
       filterString: string,
-    ): (source?: SourceIterator | string[] | Record<string, unknown>, widget?: Widget) => string[];
+    ): (
+      source?: SourceIterator | string[] | Record<string, unknown>,
+      widget?: Widget,
+    ) => string[];
     /**
      *
      * @param filterString
@@ -80,15 +83,15 @@ declare module 'tiddlywiki' {
     makeTiddlerIterator(titles: string[]): SourceIterator;
     /**
      * You can use this with `makeTiddlerIterator`:
-     * 
+     *
      * ```js
      * $tw.wiki.filterTiddlers(filter, undefined, $tw.wiki.makeTiddlerIterator(['title']))
      * ```
-     * 
+     *
      * This calls `compileFilter`
-     * @param filterString 
-     * @param widget 
-     * @param source 
+     * @param filterString
+     * @param widget
+     * @param source
      */
     filterTiddlers(
       filterString: string,
@@ -221,7 +224,7 @@ declare module 'tiddlywiki' {
       outputType: OutputMimeTypes,
       textType: TextMimeTypes,
       text: string,
-      options?: Partial<IMakeWidgetOptions> & IParserOptions,
+      options?: Partial<IMakeWidgetOptions> & IParseOptions,
     ): string;
     /**
       Make a widget tree for a parse tree
@@ -271,10 +274,51 @@ declare module 'tiddlywiki' {
     isShadowTiddler(title: string): boolean;
     isBinaryTiddler(title: string): boolean;
     isImageTiddler(title: string): boolean;
+    isSystemTiddler(title: string): boolean;
+    isTemporaryTiddler(title: string): boolean;
+    isVolatileTiddler(title: string): boolean;
+    /**
+     * Like addTiddler() except it will silently reject any plugin tiddlers that are older than the currently loaded version. Returns true if the tiddler was imported
+     */
+    importTiddler(title: string): boolean;
     /** return shadowTiddlers[title].source; */
     getShadowSource(title: string): string | null;
     getTiddlerBacklinks(targetTitle: string): string[];
     getTiddlerLinks(title: string): string[];
     getPluginInfo(title: string): { tiddlers: Record<string, ITiddlerFields> };
+    getChangeCount(title: string): number;
+    getCreationFields(): {
+      created: Date;
+      creator?: string;
+      [x: string]: unknown;
+    };
+    getModificationFields(): {
+      modified: Date;
+      modifier?: string;
+      [x: string]: unknown;
+    };
+    /**
+      Generate an unused title from the specified base
+      options.prefix must be a string
+    */
+    generateNewTitle(baseTitle: string, options: { prefix?: string }): string;
+
+    addEventListener(
+      type: string,
+      handler: (event: unknown) => void | Promise<void>,
+    ): void;
+    addEventListener(
+      type: "change",
+      handler: (change: IChangedTiddlers) => void | Promise<void>,
+    ): void;
+
+    dispatchEvent(
+      type: string,
+      dataOrEvent: unknown,
+    ): void;
+    dispatchEvent(
+      type: "change",
+      change: IChangedTiddlers,
+    ): void;
   }
 }