self-hosted/joplin
1
0
Fork 0
mirror of https://github.com/laurent22/joplin.git synced 2024-12-30 10:36:35 +02:00
Code Issues Releases Activity

Update plugin types

Browse Source
This commit is contained in:
Laurent Cozic 2023-09-17 18:09:08 +01:00
parent 510caa77cc
commit 40ddb80173
22 changed files with 22 additions and 462 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
packages/app-cli/tests/support/plugins/clipboard/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/codemirror_content_script/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/content_script/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/dialog/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/editor_context_menu/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/events/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/external_assets/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/imaging/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/jpl_test/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/json_export/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/load_css/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/menu/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/multi_selection/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/nativeModule/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/post_messages/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/register_command/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/selected_text/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/settings/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/toc/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/user_data/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/app-cli/tests/support/plugins/withExternalModules/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100

22
packages/generator-joplin/generators/app/templates/api/JoplinImaging.d.ts vendored
View File

@ -1,4 +1,4 @@
import { Rectangle } from "./types";
import { Rectangle } from './types';
export interface Implementation {
nativeImage: any;
}
@ -32,31 +32,11 @@ export default class JoplinImaging {
private createImageHandle;
private imageByHandle;
private cacheImage;
/**
* Create an image from a buffer - however only use this for very small
* images. It requires transferring the full image data from the plugin to
* the app, which is extremely slow and will freeze the app. Instead, use
* `createFromPath` or `createFromResource`, which will manipulate the image
* data directly from the main process.
*/
createFromBuffer(buffer: any, options?: CreateFromBufferOptions): Promise<Handle>;
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>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toDataUrl(handle: Handle): Promise<string>;
/**
* Warnings: requires transferring the complete image from the app to the
* plugin which may freeze the app. Consider using one of the `toXxxFile()`
* or `toXxxResource()` methods instead.
*/
toBase64(handle: Handle): Promise<string>;
toPngFile(handle: Handle, filePath: string): Promise<void>;
/**
* Quality is between 0 and 100