deps: major joplin plugin lib bump

Signed-off-by: Henrik Gerdes <[email protected]>

.github/workflows/release.yml

@@ -14,58 +14,58 @@ jobs:
       contents: write
       packages: write
     steps:
-    - name: Checkout code
-      uses: actions/checkout@v4
+      - name: Checkout code
+        uses: actions/checkout@v4
 
-    - name: Set up Node.js
-      uses: actions/setup-node@v4
-      with:
-        node-version: "${{ env.NODE_VERSION }}"
-        registry-url: "https://registry.npmjs.org"
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "${{ env.NODE_VERSION }}"
+          registry-url: "https://registry.npmjs.org"
 
-    - name: Set Version
-      run: |
-        npm version --no-commit-hooks --allow-same-version --no-git-tag-version ${{ github.ref_name }}
-        npm version
+      - name: Set Version
+        run: |
+          npm version --no-commit-hooks --allow-same-version --no-git-tag-version ${{ github.ref_name }}
+          npm version
 
-    - name: Install dependencies
-      run: npm install
+      - name: Install dependencies
+        run: npm install
 
-    - name: Run lint
-      run: npm run lint
+      - name: Run lint
+        run: npm run lint
 
-    - name: Build app
-      run: |
-        # Running test
-        if [[ "$(node --version)" == "v18"* || "$(node --version)" == "v20"* ]]; then
-          export NODE_OPTIONS=--openssl-legacy-provider
-          echo HI
-        fi
-        npm run dist
+      - name: Build app
+        run: |
+          # Running test
+          if [[ "$(node --version)" == "v18"* || "$(node --version)" == "v20"* ]]; then
+            export NODE_OPTIONS=--openssl-legacy-provider
+            echo HI
+          fi
+          npm run dist
 
-    - name: Upload artifacts
-      uses: actions/upload-artifact@v2
-      with:
-        name: build
-        path: publish
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v2
+        with:
+          name: build
+          path: publish
 
-    - name: Archive Release
-      uses: thedoctor0/[email protected]
-      with:
-        type: zip
-        filename: joplin-plugin-remote-note-pull.zip
-        path: publish
+      - name: Archive Release
+        uses: thedoctor0/[email protected]
+        with:
+          type: zip
+          filename: joplin-plugin-remote-note-pull.zip
+          path: publish
 
-    - name: Create GH release
-      uses: softprops/action-gh-release@v1
-      with:
-        name: Release ${{ github.ref_name }}
-        generate_release_notes: true
-        prerelease: false
-        files: joplin-plugin-remote-note-pull.zip
-        token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Create GH release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: Release ${{ github.ref_name }}
+          generate_release_notes: true
+          prerelease: ${{ contains( github.ref_name, 'dev' )}}
+          files: joplin-plugin-remote-note-pull.zip
+          token: ${{ secrets.GITHUB_TOKEN }}
 
-    - name: Push npm package
-      run: npm publish
-      env:
-        NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - name: Push npm package
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

.github/workflows/test-compile.yml

@@ -17,16 +17,16 @@ jobs:
   pre-commit:
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
-    - uses: pre-commit/[email protected]
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+      - uses: pre-commit/[email protected]
 
   test-build:
     runs-on: ubuntu-latest
     strategy:
       fail-fast: false
       matrix:
-        node-version: ["16", "18", "20"]
+        node-version: ["18", "20"]
 
     steps:
       - name: Checkout Code

api/Joplin.d.ts

@@ -10,6 +10,8 @@ import JoplinSettings from './JoplinSettings';
 import JoplinContentScripts from './JoplinContentScripts';
 import JoplinClipboard from './JoplinClipboard';
 import JoplinWindow from './JoplinWindow';
+import BasePlatformImplementation from '../BasePlatformImplementation';
+import JoplinImaging from './JoplinImaging';
 /**
  * This is the main entry point to the Joplin API. You can access various services using the provided accessors.
  *
@@ -25,6 +27,7 @@ import JoplinWindow from './JoplinWindow';
 export default class Joplin {
     private data_;
     private plugins_;
+    private imaging_;
     private workspace_;
     private filters_;
     private commands_;
@@ -34,9 +37,11 @@ export default class Joplin {
     private contentScripts_;
     private clipboard_;
     private window_;
-    constructor(implementation: any, plugin: Plugin, store: any);
+    private implementation_;
+    constructor(implementation: BasePlatformImplementation, plugin: Plugin, store: any);
     get data(): JoplinData;
     get clipboard(): JoplinClipboard;
+    get imaging(): JoplinImaging;
     get window(): JoplinWindow;
     get plugins(): JoplinPlugins;
     get workspace(): JoplinWorkspace;
@@ -65,4 +70,5 @@ export default class Joplin {
      * [View the demo plugin](https://github.com/laurent22/joplin/tree/dev/packages/app-cli/tests/support/plugins/nativeModule)
      */
     require(_path: string): any;
+    versionInfo(): Promise<import("./types").VersionInfo>;
 }

api/JoplinData.d.ts

@@ -1,7 +1,8 @@
 import { ModelType } from '../../../BaseModel';
+import Plugin from '../Plugin';
 import { Path } from './types';
 /**
- * This module provides access to the Joplin data API: https://joplinapp.org/api/references/rest_api/
+ * This module provides access to the Joplin data API: https://joplinapp.org/help/api/references/rest_api
  * This is the main way to retrieve data, such as notes, notebooks, tags, etc.
  * or to update them or delete them.
  *
@@ -17,7 +18,7 @@ import { Path } from './types';
  * * `data`: (Optional) Applies to PUT and POST calls only. The request body contains the data you want to create or modify, for example the content of a note or folder.
  * * `files`: (Optional) Used to create new resources and associate them with files.
  *
- * Please refer to the [Joplin API documentation](https://joplinapp.org/api/references/rest_api/) for complete details about each call. As the plugin runs within the Joplin application **you do not need an authorisation token** to use this API.
+ * Please refer to the [Joplin API documentation](https://joplinapp.org/help/api/references/rest_api) for complete details about each call. As the plugin runs within the Joplin application **you do not need an authorisation token** to use this API.
  *
  * For example:
  *
@@ -39,6 +40,8 @@ import { Path } from './types';
 export default class JoplinData {
     private api_;
     private pathSegmentRegex_;
+    private plugin;
+    constructor(plugin: Plugin);
     private serializeApiBody;
     private pathToString;
     get(path: Path, query?: any): Promise<any>;
@@ -47,4 +50,24 @@ export default class JoplinData {
     delete(path: Path, query?: any): Promise<any>;
     itemType(itemId: string): Promise<ModelType>;
     resourcePath(resourceId: string): Promise<string>;
+    /**
+     * Gets an item user data. User data are key/value pairs. The `key` can be any
+     * arbitrary string, while the `value` can be of any type supported by
+     * [JSON.stringify](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#description)
+     *
+     * User data is synchronised across devices, and each value wil be merged based on their timestamp:
+     *
+     * - If value is modified by client 1, then modified by client 2, it will take the value from client 2
+     * - If value is modified by client 1, then deleted by client 2, the value will be deleted after merge
+     * - If value is deleted by client 1, then updated by client 2, the value will be restored and set to the value from client 2 after merge
+     */
+    userDataGet<T>(itemType: ModelType, itemId: string, key: string): Promise<T>;
+    /**
+     * Sets a note user data. See {@link JoplinData.userDataGet} for more details.
+     */
+    userDataSet<T>(itemType: ModelType, itemId: string, key: string, value: T): Promise<void>;
+    /**
+     * Deletes a note user data. See {@link JoplinData.userDataGet} for more details.
+     */
+    userDataDelete(itemType: ModelType, itemId: string, key: string): Promise<void>;
 }

api/JoplinImaging.d.ts

@@ -0,0 +1,61 @@
+import { Rectangle } from './types';
+export interface Implementation {
+    nativeImage: any;
+}
+export interface CreateFromBufferOptions {
+    width?: number;
+    height?: number;
+    scaleFactor?: number;
+}
+export interface ResizeOptions {
+    width?: number;
+    height?: number;
+    quality?: 'good' | 'better' | 'best';
+}
+export type Handle = string;
+/**
+ * Provides imaging functions to resize or process images. You create an image
+ * using one of the `createFrom` functions, then use the other functions to
+ * process the image.
+ *
+ * Images are associated with a handle which is what will be available to the
+ * plugin. Once you are done with an image, free it using the `free()` function.
+ *
+ * [View the
+ * example](https://github.com/laurent22/joplin/blob/dev/packages/app-cli/tests/support/plugins/imaging/src/index.ts)
+ *
+ */
+export default class JoplinImaging {
+    private implementation_;
+    private images_;
+    constructor(implementation: Implementation);
+    private createImageHandle;
+    private imageByHandle;
+    private cacheImage;
+    createFromPath(filePath: string): Promise<Handle>;
+    createFromResource(resourceId: string): Promise<Handle>;
+    getSize(handle: Handle): Promise<any>;
+    resize(handle: Handle, options?: ResizeOptions): Promise<string>;
+    crop(handle: Handle, rectange: Rectangle): Promise<string>;
+    toPngFile(handle: Handle, filePath: string): Promise<void>;
+    /**
+     * Quality is between 0 and 100
+     */
+    toJpgFile(handle: Handle, filePath: string, quality?: number): Promise<void>;
+    private tempFilePath;
+    /**
+     * Creates a new Joplin resource from the image data. The image will be
+     * first converted to a JPEG.
+     */
+    toJpgResource(handle: Handle, resourceProps: any, quality?: number): Promise<import("../../database/types").ResourceEntity>;
+    /**
+     * Creates a new Joplin resource from the image data. The image will be
+     * first converted to a PNG.
+     */
+    toPngResource(handle: Handle, resourceProps: any): Promise<import("../../database/types").ResourceEntity>;
+    /**
+     * Image data is not automatically deleted by Joplin so make sure you call
+     * this method on the handle once you are done.
+     */
+    free(handle: Handle): Promise<void>;
+}

api/JoplinInterop.d.ts

@@ -9,7 +9,7 @@ import { ExportModule, ImportModule } from './types';
  *
  * See the documentation of the [[ExportModule]] and [[ImportModule]] for more information.
  *
- * You may also want to refer to the Joplin API documentation to see the list of properties for each item (note, notebook, etc.) - https://joplinapp.org/api/references/rest_api/
+ * You may also want to refer to the Joplin API documentation to see the list of properties for each item (note, notebook, etc.) - https://joplinapp.org/help/api/references/rest_api
  */
 export default class JoplinInterop {
     registerExportModule(module: ExportModule): Promise<void>;

api/JoplinSettings.d.ts

@@ -6,7 +6,8 @@ export interface ChangeEvent {
      */
     keys: string[];
 }
-export declare type ChangeHandler = (event: ChangeEvent) => void;
+export type ChangeHandler = (event: ChangeEvent) => void;
+export declare const namespacedKey: (pluginId: string, key: string) => string;
 /**
  * This API allows registering new settings and setting sections, as well as getting and setting settings. Once a setting has been registered it will appear in the config screen and be editable by the user.
  *
@@ -19,8 +20,6 @@ export declare type ChangeHandler = (event: ChangeEvent) => void;
 export default class JoplinSettings {
     private plugin_;
     constructor(plugin: Plugin);
-    private get keyPrefix();
-    private namespacedKey;
     /**
      * Registers new settings.
      * Note that registering a setting item is dynamic and will be gone next time Joplin starts.

api/JoplinViews.d.ts

@@ -4,6 +4,7 @@ import JoplinViewsMenuItems from './JoplinViewsMenuItems';
 import JoplinViewsMenus from './JoplinViewsMenus';
 import JoplinViewsToolbarButtons from './JoplinViewsToolbarButtons';
 import JoplinViewsPanels from './JoplinViewsPanels';
+import JoplinViewsNoteList from './JoplinViewsNoteList';
 /**
  * This namespace provides access to view-related services.
  *
@@ -13,16 +14,18 @@ import JoplinViewsPanels from './JoplinViewsPanels';
 export default class JoplinViews {
     private store;
     private plugin;
-    private dialogs_;
     private panels_;
     private menuItems_;
     private menus_;
     private toolbarButtons_;
+    private dialogs_;
+    private noteList_;
     private implementation_;
     constructor(implementation: any, plugin: Plugin, store: any);
     get dialogs(): JoplinViewsDialogs;
     get panels(): JoplinViewsPanels;
     get menuItems(): JoplinViewsMenuItems;
     get menus(): JoplinViewsMenus;
     get toolbarButtons(): JoplinViewsToolbarButtons;
+    get noteList(): JoplinViewsNoteList;
 }

api/JoplinViewsDialogs.d.ts

@@ -43,6 +43,12 @@ export default class JoplinViewsDialogs {
      * Displays a message box with OK/Cancel buttons. Returns the button index that was clicked - "0" for OK and "1" for "Cancel"
      */
     showMessageBox(message: string): Promise<number>;
+    /**
+     * Displays a dialog to select a file or a directory. Same options and
+     * output as
+     * https://www.electronjs.org/docs/latest/api/dialog#dialogshowopendialogbrowserwindow-options
+     */
+    showOpenDialog(options: any): Promise<any>;
     /**
      * Sets the dialog HTML content
      */

api/JoplinViewsNoteList.d.ts

@@ -0,0 +1,24 @@
+import { Store } from 'redux';
+import Plugin from '../Plugin';
+import { ListRenderer } from './noteListType';
+/**
+ * This API allows you to customise how each note in the note list is rendered.
+ * The renderer you implement follows a unidirectional data flow.
+ *
+ * The app provides the required dependencies whenever a note is updated - you
+ * process these dependencies, and return some props, which are then passed to
+ * your template and rendered. See [[[ListRenderer]]] for a detailed description
+ * of each property of the renderer.
+ *
+ * [View the demo plugin](https://github.com/laurent22/joplin/tree/dev/packages/app-cli/tests/support/plugins/note_list_renderer)
+ *
+ * The default list renderer is implemented using the same API, so it worth checking it too:
+ *
+ * [Default list renderer](https://github.com/laurent22/joplin/tree/dev/packages/lib/services/noteList/defaultListRenderer.ts)
+ */
+export default class JoplinViewsNoteList {
+    private plugin_;
+    private store_;
+    constructor(plugin: Plugin, store: Store);
+    registerRenderer(renderer: ListRenderer): Promise<void>;
+}

api/JoplinWorkspace.d.ts

@@ -3,7 +3,7 @@ import { Disposable, MenuItem } from './types';
 export interface EditContextMenuFilterObject {
     items: MenuItem[];
 }
-declare type FilterHandler<T> = (object: T) => Promise<void>;
+type FilterHandler<T> = (object: T) => Promise<void>;
 declare enum ItemChangeEventType {
     Create = 1,
     Update = 2,
@@ -19,9 +19,9 @@ interface SyncStartEvent {
 interface ResourceChangeEvent {
     id: string;
 }
-declare type ItemChangeHandler = (event: ItemChangeEvent) => void;
-declare type SyncStartHandler = (event: SyncStartEvent) => void;
-declare type ResourceChangeHandler = (event: ResourceChangeEvent) => void;
+type ItemChangeHandler = (event: ItemChangeEvent) => void;
+type SyncStartHandler = (event: SyncStartEvent) => void;
+type ResourceChangeHandler = (event: ResourceChangeEvent) => void;
 /**
  * The workspace service provides access to all the parts of Joplin that
  * are being worked on - i.e. the currently selected notes or notebooks as