@imgly/plugin-ai-generation-web 0.1.9 → 0.2.0

package/dist/{generation/middleware → middleware}/alwaysOnTopMiddleware.d.ts

@@ -1,5 +1,5 @@
 import { Middleware } from './middleware';
-import { Output } from '../provider';
+import { Output } from '../core/provider';
 /**
  * Sets the blocks to a pending state while the middleware is running.
  */

package/dist/{generation/middleware → middleware}/dryRunMiddleware.d.ts

@@ -1,6 +1,7 @@
-import { type Output, type OutputKind, type GetBlockInputResult } from '../provider';
+import { type Output, type OutputKind, type GetBlockInputResult } from '../core/provider';
 import { Middleware } from './middleware';
 interface DryRunOptions<K extends OutputKind> {
+    enable?: boolean;
     kind: K;
     blockInputs?: GetBlockInputResult<K>;
     blockIds?: number[];

package/dist/{generation/middleware → middleware}/editModeMiddleware.d.ts

@@ -1,5 +1,5 @@
 import { Middleware } from './middleware';
-import { Output } from '../provider';
+import { Output } from '../core/provider';
 /**
  * For a given edit mode and block ids, this middleware will
  * ensure that as long as these blocks are selected, the edit mode is

package/dist/{generation/middleware → middleware}/highlightBlocksMiddleware.d.ts

@@ -1,5 +1,5 @@
 import { Middleware } from './middleware';
-import { Output } from '../provider';
+import { Output } from '../core/provider';
 /**
  * Highlights the blocks while the middleware is running.
  *

package/dist/middleware/lockEditModeMiddleware.d.ts

@@ -0,0 +1,17 @@
+import { Middleware } from './middleware';
+import { Output } from '../core/provider';
+/**
+ * For a given edit mode and block ids, this middleware will
+ * ensure that as long as these blocks are selected, the edit mode is
+ * set to the given edit mode and cannot be changed.
+ *
+ * The use-case is to show only the generation canvas menu during
+ * the generation process.
+ */
+declare function lockEditModeMiddleware<I, O extends Output>({ editMode }: {
+    /**
+     * The edit mode to lock the selection to.
+     */
+    editMode: string;
+}): Middleware<I, O>;
+export default lockEditModeMiddleware;

package/dist/{generation/middleware → middleware}/lockMiddleware.d.ts

@@ -1,5 +1,5 @@
 import { Middleware } from './middleware';
-import { Output } from '../provider';
+import { Output } from '../core/provider';
 /**
  * Highlights the blocks while the middleware is running.
  */

package/dist/middleware/loggingMiddleware.d.ts

@@ -0,0 +1,6 @@
+import { Output } from '../core/provider';
+import { Middleware } from './middleware';
+declare function loggingMiddleware<I, O extends Output>({ enable }: {
+    enable: boolean | undefined;
+}): Middleware<I, O>;
+export default loggingMiddleware;

package/dist/{generation/middleware → middleware}/middleware.d.ts

@@ -1,4 +1,4 @@
-import { GenerationOptions, GenerationResult, Output } from '../provider';
+import { GenerationOptions, GenerationResult, Output } from '../core/provider';
 /**
  * Result of the generation with a dispose function to clean up
  */

package/dist/{generation/middleware → middleware}/pendingMiddleware.d.ts

@@ -1,14 +1,14 @@
 import { Middleware } from './middleware';
-import { Output } from '../provider';
+import { Output } from '../core/provider';
 /**
  * Sets the blocks to a pending state while the middleware is running.
  */
-declare function pendingMiddleware<I, O extends Output>({ pending }: {
+declare function pendingMiddleware<I, O extends Output>({ enable }: {
     /**
      * Should the blocks be set to a pending state?
      *
      * @default true
      */
-    pending?: boolean;
+    enable?: boolean;
 }): Middleware<I, O>;
 export default pendingMiddleware;

package/dist/{generation/middleware → middleware}/rateLimitMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { GenerationOptions, Output } from '../provider';
+import { GenerationOptions, Output } from '../core/provider';
 import { Middleware } from './middleware';
 export interface RateLimitOptions<I> {
     /**

package/dist/{generation/middleware → middleware}/uploadMiddleware.d.ts

@@ -1,4 +1,4 @@
-import { Output } from '../provider';
+import { Output } from '../core/provider';
 import { Middleware } from './middleware';
 /**
  * Middleware to upload the output of a generation process.

package/dist/{generation/openapi → openapi}/getProperties.d.ts

@@ -1,5 +1,5 @@
 import { OpenAPIV3 } from 'openapi-types';
-import { OutputKind, PanelInputSchema } from '../provider';
+import { OutputKind, PanelInputSchema } from '../core/provider';
 import { Property } from './types';
 declare function getProperties<K extends OutputKind, I>(inputSchema: OpenAPIV3.SchemaObject, panelInput: PanelInputSchema<K, I>): Property[];
 export default getProperties;

package/dist/{generation/openapi → openapi}/renderProperty.d.ts

@@ -1,6 +1,6 @@
 import { BuilderRenderFunctionContext } from '@cesdk/cesdk-js';
 import { GetPropertyInput, Property } from './types';
-import Provider, { Output, OutputKind, PanelInputSchema } from '../provider';
-import { InitProviderConfiguration, UIOptions } from '../types';
-declare function renderProperty<K extends OutputKind, I, O extends Output>(context: BuilderRenderFunctionContext<any>, property: Property, provider: Provider<K, I, O>, panelInput: PanelInputSchema<K, I>, options: UIOptions, config: InitProviderConfiguration): GetPropertyInput | undefined;
+import Provider, { Output, OutputKind, PanelInputSchema } from '../core/provider';
+import { UIOptions, CommonConfiguration } from '../types';
+declare function renderProperty<K extends OutputKind, I, O extends Output>(context: BuilderRenderFunctionContext<any>, property: Property, provider: Provider<K, I, O>, panelInput: PanelInputSchema<K, I>, options: UIOptions, config: CommonConfiguration<I, O>): GetPropertyInput | undefined;
 export default renderProperty;

package/dist/{generation/quickAction/consumeGeneratedResult.d.ts → providers/getApplyCallbacks.d.ts}

@@ -1,14 +1,19 @@
 import type CreativeEditorSDK from '@cesdk/cesdk-js';
-import { GenerationResult, type Output, type OutputKind } from '../provider';
-import { ApplyCallbacks } from './types';
-type ConsumeGeneratedResultOptions = {
+import { type Output, type OutputKind } from '../core/provider';
+import { ResultSuccess } from '../generation/createGenerateFunction';
+export type ApplyCallbacks = {
+    onBefore: () => void;
+    onAfter: () => void;
+    onCancel: () => void;
+    onApply: () => void;
+};
+type GetApplyCallbacksOptions = {
     kind: OutputKind;
     blockIds: number[];
     cesdk: CreativeEditorSDK;
-    abortSignal: AbortSignal;
+    abortSignal?: AbortSignal;
 };
-type ReturnValue<O extends Output> = {
-    consumedGenerationResult: O;
+type ReturnValue = {
     applyCallbacks: ApplyCallbacks;
 };
 /**
@@ -19,5 +24,5 @@ type ReturnValue<O extends Output> = {
  * is streamed to the text block, while the image generation is applied to the fill
  * block with a source set and the same crop applied.
  */
-declare function consumeGeneratedResult<O extends Output>(result: GenerationResult<O>, options: ConsumeGeneratedResultOptions): Promise<ReturnValue<O>>;
-export default consumeGeneratedResult;
+declare function getApplyCallbacks<O extends Output>(result: ResultSuccess<O>, options: GetApplyCallbacksOptions): Promise<ReturnValue>;
+export default getApplyCallbacks;

package/dist/providers/getCanvasMenuComponentId.d.ts

@@ -0,0 +1,3 @@
+import { OutputKind } from '../core/provider';
+declare function getQuickActionCanvasMenuComponentId<K extends OutputKind>(kind: K): string;
+export default getQuickActionCanvasMenuComponentId;

package/dist/providers/initializeProvider.d.ts

@@ -0,0 +1,22 @@
+import CreativeEditorSDK, { BuilderRenderFunction } from '@cesdk/cesdk-js';
+import Provider, { Output, OutputKind } from '../core/provider';
+import { CommonPluginConfiguration } from '../types';
+import { type Generate } from '../generation/createGenerateFunction';
+export type ProviderInitializationResult<K extends OutputKind, I, O extends Output> = {
+    provider: Provider<K, I, O>;
+    panel: {
+        builderRenderFunction?: BuilderRenderFunction;
+    };
+    history: {
+        assetSourceId?: string;
+        assetLibraryEntryId?: string;
+    };
+    generate: Generate<I, O>;
+};
+/**
+ * Initializes a provider with the given configuration and options.
+ */
+declare function initializeProvider<K extends OutputKind, I, O extends Output>(_kind: K, provider: Provider<K, I, O>, options: {
+    cesdk: CreativeEditorSDK;
+}, config: CommonPluginConfiguration<K, I, O>): Promise<ProviderInitializationResult<K, I, O>>;
+export default initializeProvider;

package/dist/providers/initializeProviders.d.ts

@@ -0,0 +1,38 @@
+import CreativeEditorSDK, { BuilderRenderFunction } from '@cesdk/cesdk-js';
+import Provider, { Output, OutputKind } from '../core/provider';
+import { ProviderInitializationResult } from './initializeProvider';
+import { CommonPluginConfiguration } from '../types';
+export type ProvidersInitializationResult<K extends OutputKind, I, O extends Output> = {
+    /**
+     * Combined panel render function for all providers.
+     */
+    panel: {
+        builderRenderFunction?: BuilderRenderFunction;
+    };
+    /**
+     * Combined history asset source and library entry IDs for the providers.
+     */
+    history?: {
+        assetSourceId?: string;
+        assetLibraryEntryId?: string;
+    };
+    /**
+     * All individual initialization results of the providers, i.e.
+     * the result of `initializeProvider` for every provider.
+     */
+    providerInitializationResults: ProviderInitializationResult<K, I, O>[];
+};
+/**
+ * Initializes the given providers for the specified output kind.
+ *
+ * - It will create a combined render function for all providers
+ *   that can be used in a panel
+ *
+ */
+declare function initializeProviders<K extends OutputKind, I, O extends Output>(kind: K, providers: {
+    fromText: Provider<K, I, O>[];
+    fromImage: Provider<K, I, O>[];
+} | Provider<K, I, O>[], options: {
+    cesdk: CreativeEditorSDK;
+}, config: CommonPluginConfiguration<K, I, O>): Promise<ProvidersInitializationResult<K, I, O>>;
+export default initializeProviders;

package/dist/types.d.ts

@@ -0,0 +1,101 @@
+import type CreativeEditorSDK from '@cesdk/cesdk-js';
+import { type CreativeEngine } from '@cesdk/cesdk-js';
+import type Provider from './core/provider';
+import { Output, OutputKind, PanelInput } from './core/provider';
+import { Middleware } from './middleware/middleware';
+/**
+ * A common configuration used by the plugins and the provider.
+ */
+export interface CommonConfiguration<I, O extends Output> {
+    /**
+     * Render console logs for debugging purposes.
+     */
+    debug?: boolean;
+    /**
+     * Dry run mode. If set to true, the plugin will not make any API calls.
+     */
+    dryRun?: boolean;
+    /**
+     * Middlewares to add to the provider generation
+     */
+    middlewares?: Middleware<I, O>[];
+}
+/**
+ * Configuration to set provider and models for image generation.
+ */
+export interface CommonPluginConfiguration<K extends OutputKind, I, O extends Output> extends CommonConfiguration<I, O> {
+    /**
+     * Base URL used for the UI assets used in the plugin.
+     *
+     * By default, we load the assets from the IMG.LY CDN. You can copy the assets.
+     * from the `/assets` folder to your own server and set the base URL to your server.
+     */
+    baseURL?: string;
+}
+/**
+ * Returns a provider for a given cesdk instance.
+ */
+export type GetProvider<K extends OutputKind> = ({ cesdk }: {
+    cesdk: CreativeEditorSDK;
+}) => Promise<Provider<K, any, any>>;
+/**
+ * Common provider configuration that all providers should provide.
+ */
+export interface CommonProviderConfiguration<I, O extends Output> extends CommonConfiguration<I, O> {
+    /**
+     * The proxy URL to use for the provider.
+     */
+    proxyUrl: string;
+    /**
+     * Headers that shall be sent with the request of the provider.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Middlewares to add to the provider generation
+     * @deprecated Use `middlewares` instead.
+     */
+    middleware?: Middleware<I, O>[];
+}
+/**
+ * Internal configuration interface for provider initialization.
+ * This extends the public CommonPluginConfiguration with required provider field.
+ */
+export interface InternalPluginConfiguration<K extends OutputKind, I, O extends Output> extends CommonConfiguration<I, O> {
+    /**
+     * The provider to use for generation.
+     */
+    provider: Provider<K, I, O>;
+    /**
+     * The panel input schema to use for the provider.
+     */
+    panelInput?: PanelInput<K, I>;
+}
+/**
+ * Context for provider initialization, including the provider, panel input schema,
+ * options, and configuration.
+ */
+export type InitializationContext<K extends OutputKind, I, O extends Output, P extends PanelInput<K, I> = PanelInput<K, I>> = {
+    provider: Provider<K, I, O>;
+    panelInput?: P;
+    options: UIOptions;
+    config: InternalPluginConfiguration<K, I, O>;
+};
+/**
+ * Options for UI interactions
+ */
+export type UIOptions = {
+    cesdk: CreativeEditorSDK;
+    engine: CreativeEngine;
+    historyAssetSourceId?: string;
+    historyAssetLibraryEntryId?: string;
+    i18n?: {
+        prompt?: string;
+    };
+};
+/**
+ * Basic context for provider initialization
+ */
+export type Options = {
+    cesdk?: CreativeEditorSDK;
+    engine: CreativeEngine;
+};

package/dist/{common → ui/common}/renderImageUrlProperty.d.ts

@@ -1,5 +1,5 @@
 import CreativeEditorSDK from '@cesdk/cesdk-js';
-import { RenderCustomProperty } from '../generation/provider';
+import { RenderCustomProperty } from '../../core/provider';
 /**
  * Provides render function for a image url property that allows
  * to select an image from the library with a MediaPreview

package/dist/{common → ui/common}/renderStyleTransferProperty.d.ts

@@ -1,5 +1,5 @@
 import CreativeEditorSDK from '@cesdk/cesdk-js';
-import { RenderCustomProperty } from '../generation/provider';
+import { RenderCustomProperty } from '../../core/provider';
 type Style = {
     id: 'none' | (string & {});
     label: string;

package/dist/{generation → ui/components}/renderGenerationComponents.d.ts

@@ -1,15 +1,16 @@
 import { type BuilderRenderFunctionContext } from '@cesdk/cesdk-js';
-import type Provider from './provider';
-import { type GetInput, type OutputKind, type Output, type GetBlockInput } from './provider';
-import { InitProviderConfiguration, UIOptions } from './types';
+import type Provider from '../../core/provider';
+import { type GetInput, type OutputKind, type Output, type GetBlockInput } from '../../core/provider';
+import { UIOptions, CommonConfiguration } from '../../types';
+import { Generate } from '../../generation/createGenerateFunction';
 export declare function isGeneratingStateKey(providerId: string): string;
 export declare function abortGenerationStateKey(providerId: string): string;
 /**
  * Renders the generation UI components and sets up event handlers
  */
-declare function renderGenerationComponents<K extends OutputKind, I, O extends Output>(context: BuilderRenderFunctionContext<any>, provider: Provider<K, I, O>, getInput: GetInput<I>, getBlockInput: GetBlockInput<K, I>, options: UIOptions & {
+declare function renderGenerationComponents<K extends OutputKind, I, O extends Output>(context: BuilderRenderFunctionContext<any>, provider: Provider<K, I, O>, generate: Generate<I, O>, getInput: GetInput<I>, getBlockInput: GetBlockInput<K, I>, options: UIOptions & {
     createPlaceholderBlock?: boolean;
     includeHistoryLibrary?: boolean;
     requiredInputs?: string[];
-}, config: InitProviderConfiguration): void;
+}, config: CommonConfiguration<I, O>): void;
 export default renderGenerationComponents;

package/dist/ui/panels/createConfirmationRenderFunction.d.ts

@@ -0,0 +1,16 @@
+import CreativeEditorSDK, { BuilderRenderFunction } from '@cesdk/cesdk-js';
+import { OutputKind } from '../../core/provider';
+import { Callbacks } from '../../generation/CallbacksRegistry';
+/**
+ * Creates a render function for the AI inference confirmation component.
+ *
+ * It will render 'cancel', 'before', 'after', and 'apply' buttons once the
+ * inference is done. Until then a loading spinner is shown with a cancel button.
+ *
+ * The callbacks are provided by the payload from the context.
+ */
+declare function createConfirmationRenderFunction<K extends OutputKind>(context: {
+    kind: K;
+    cesdk: CreativeEditorSDK;
+}): Promise<BuilderRenderFunction<Callbacks>>;
+export default createConfirmationRenderFunction;

package/dist/ui/panels/createPanelRenderFunction.d.ts

@@ -0,0 +1,9 @@
+import { BuilderRenderFunction } from '@cesdk/cesdk-js';
+import { Output, OutputKind } from '../../core/provider';
+import { InitializationContext } from '../../types';
+import { Generate } from '../../generation/createGenerateFunction';
+/**
+ * Creates a panel render function based on the provided context, i.e. on the provider.
+ */
+declare function createPanelRenderFunction<K extends OutputKind, I, O extends Output>(context: InitializationContext<K, I, O>, generate: Generate<I, O>): Promise<BuilderRenderFunction<any> | undefined>;
+export default createPanelRenderFunction;

package/dist/ui/panels/createPanelRenderFunctionFromCustom.d.ts

@@ -0,0 +1,6 @@
+import { BuilderRenderFunction } from '@cesdk/cesdk-js';
+import { OutputKind, PanelInputCustom, type Output } from '../../core/provider';
+import { InitializationContext } from '../../types';
+import { Generate } from '../../generation/createGenerateFunction';
+declare function createPanelRenderFunctionFromCustom<K extends OutputKind, I, O extends Output>({ options, provider, panelInput, config }: InitializationContext<K, I, O, PanelInputCustom<K, I>>, generate: Generate<I, O>): Promise<BuilderRenderFunction<any> | undefined>;
+export default createPanelRenderFunctionFromCustom;

package/dist/ui/panels/createPanelRenderFunctionFromSchema.d.ts

@@ -0,0 +1,9 @@
+import { BuilderRenderFunction } from '@cesdk/cesdk-js';
+import { OutputKind, PanelInputSchema, type Output } from '../../core/provider';
+import { InitializationContext } from '../../types';
+import { Generate } from '../../generation/createGenerateFunction';
+/**
+ * Creates a panel render function based on the schema definition in the provider.
+ */
+declare function createPanelRenderFunctionFromSchema<K extends OutputKind, I, O extends Output>({ options, provider, panelInput, config }: InitializationContext<K, I, O, PanelInputSchema<K, I>>, generate: Generate<I, O>): Promise<BuilderRenderFunction<any> | undefined>;
+export default createPanelRenderFunctionFromSchema;

package/dist/ui/quickActions/createQuickActionMenuRenderFunction.d.ts

@@ -0,0 +1,13 @@
+import CreativeEditorSDK, { BuilderRenderFunction, CreativeEngine } from '@cesdk/cesdk-js';
+import { Output, OutputKind } from '../../core/provider';
+import { ProviderInitializationResult } from '../../providers/initializeProvider';
+declare function createQuickActionMenuRenderFunction<K extends OutputKind, I, O extends Output>(context: {
+    kind: K;
+    providerInitializationResults: ProviderInitializationResult<K, I, O>[];
+    cesdk: CreativeEditorSDK;
+    engine: CreativeEngine;
+    debug?: boolean;
+    dryRun?: boolean;
+    defaultOrder?: string[];
+}): Promise<BuilderRenderFunction<any>>;
+export default createQuickActionMenuRenderFunction;

package/dist/ui/quickActions/getQuickActionOrder.d.ts

@@ -0,0 +1,12 @@
+import CreativeEditorSDK, { ComponentPayload } from '@cesdk/cesdk-js';
+import { OutputKind } from '../../core/provider';
+/**
+ * Returns the current order of quick actions for a particular kind.
+ */
+declare function getQuickActionOrder<K extends OutputKind>(context: {
+    kind: K;
+    cesdk: CreativeEditorSDK;
+    payload?: ComponentPayload;
+    defaultOrder?: string[];
+}): string[];
+export default getQuickActionOrder;

package/dist/ui/quickActions/initializeQuickActionComponents.d.ts

@@ -0,0 +1,15 @@
+import CreativeEditorSDK, { BuilderRenderFunction, CreativeEngine } from '@cesdk/cesdk-js';
+import { Output, OutputKind } from '../../core/provider';
+import { ProviderInitializationResult } from '../../providers/initializeProvider';
+declare function initializeQuickActionComponents<K extends OutputKind, I, O extends Output>(context: {
+    kind: K;
+    providerInitializationResults: ProviderInitializationResult<K, I, O>[];
+    cesdk: CreativeEditorSDK;
+    engine: CreativeEngine;
+    debug?: boolean;
+    dryRun?: boolean;
+    defaultOrder?: string[];
+}): Promise<{
+    renderFunction: BuilderRenderFunction<any>;
+}>;
+export default initializeQuickActionComponents;

package/dist/ui/quickActions/types.d.ts

@@ -0,0 +1,10 @@
+export type InferenceStatus = 'processing' | 'confirmation';
+export type InferenceProcessingMetadata = {
+    status: 'processing';
+    quickActionId: string;
+};
+export type InferenceConfirmationMetadata = {
+    status: 'confirmation';
+    quickActionId: string;
+};
+export type InferenceMetadata = InferenceProcessingMetadata | InferenceConfirmationMetadata;

package/dist/ui/quickActions/utils.d.ts

@@ -0,0 +1,7 @@
+export declare const AI_EDIT_MODE = "ly.img.ai.editMode";
+export declare const AI_METADATA_KEY = "ly.img.ai.metadata";
+export declare const AI_CONFIRMATION_COMPONENT_ID = "ly.img.ai.confirmation.canvasMenu";
+export declare function getFeatureIdForQuickAction(options: {
+    quickActionId: string;
+    quickActionMenuId: string;
+}): string;

package/dist/utils/checkAiPluginVersion.d.ts

@@ -0,0 +1,10 @@
+import type CreativeEditorSDK from '@cesdk/cesdk-js';
+/**
+ * Checks if the current AI plugin version matches the shared version across all AI plugins.
+ * Issues a console warning if versions don't match.
+ *
+ * @param cesdk - The CreativeEditorSDK instance
+ * @param pluginId - The ID of the current plugin
+ * @param currentVersion - The version of the current plugin
+ */
+export declare function checkAiPluginVersion(cesdk: CreativeEditorSDK, pluginId: string, currentVersion: string): void;

package/dist/utils/compactSeparators.d.ts

@@ -0,0 +1,7 @@
+/**
+ * For the given array that contains strings `ly.img.separator` and other items,
+ * this function will remove all leading and trailing separators,
+ * as well as any consecutive separators in between.
+ */
+declare function compactSeparators<T>(quickActions: (T | 'ly.img.separator')[]): (T | 'ly.img.separator')[];
+export default compactSeparators;

package/dist/utils/lockSelectionToEditMode.d.ts

@@ -0,0 +1,12 @@
+import { CreativeEngine } from '@cesdk/cesdk-js';
+/**
+ * Locks the selection to the given block ids with the given edit mode.
+ *
+ * @returns A function to unlock the selection. Will set the edit mode back to what it was before the lock.
+ */
+declare function lockSelectionToEditMode(options: {
+    engine: CreativeEngine;
+    blockIdsToLock: number[];
+    editModeToLockTo: string;
+}): () => void;
+export default lockSelectionToEditMode;

package/dist/{utils.d.ts → utils/utils.d.ts}

@@ -1,5 +1,5 @@
 import CreativeEditorSDK, { AssetResult } from '@cesdk/cesdk-js';
-import { GenerationResult, Output } from './generation/provider';
+import { GenerationResult, Output } from '../core/provider';
 export declare const AI_PANEL_ID_PREFIX = "ly.img.ai";
 /**
  * Adding asset to the scene.
@@ -64,3 +64,8 @@ export declare function getLabelFromId(id: string): string;
  */
 export declare function isAsyncGenerator<O extends Output, C>(value: GenerationResult<O, C>): value is AsyncGenerator<O, C>;
 export declare function isAbortError(error: unknown): error is Error;
+/**
+ * Adds an icon set to the CreativeEditorSDK UI only once. Marks
+ * it as added in the global state to prevent multiple additions.
+ */
+export declare function addIconSetOnce(cesdk: CreativeEditorSDK, id: string, icons: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@imgly/plugin-ai-generation-web",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "AI generation plugin for the CE.SDK editor",
   "keywords": ["CE.SDK", "plugin", "AI", "ai generation"],
   "repository": {
@@ -38,7 +38,7 @@
     "test:watch": "jest --watch",
     "test:coverage": "jest --coverage",
     "dev": "pnpm --filter \"${npm_package_name}^...\" --parallel run dev:wait && node scripts/watch.mjs",
-    "dev:wait": "pnpm exec wait-on ./dist/index.mjs ./dist/index.d.ts --window 250 --timeout 30000",
+    "dev:wait": "pnpm exec wait-on ./dist/index.mjs ./dist/index.d.ts --window 250 --timeout 60000",
     "check:all": "concurrently -n lint,type,pretty \"pnpm run check:lint\" \"pnpm run check:types\" \"pnpm run check:pretty\"",
     "check:lint": "eslint --max-warnings 0 './src/**/*.{ts,tsx}'",
     "check:pretty": "prettier --list-different './src/**/*.{ts,tsx}'",

package/dist/generation/generate.d.ts

@@ -1,16 +0,0 @@
-import type Provider from './provider';
-import { type GetInput, type GetBlockInput, OutputKind, type Output } from './provider';
-import { InitProviderConfiguration, UIOptions } from './types';
-type Result<O> = {
-    status: 'success';
-    output: O;
-} | {
-    status: 'aborted';
-};
-/**
- * Generate content using the provider with the given input
- */
-declare function generate<K extends OutputKind, I, O extends Output>(kind: K, getInput: GetInput<I>, getBlockInput: GetBlockInput<K, I>, provider: Provider<K, I, O>, options: UIOptions & {
-    createPlaceholderBlock?: boolean;
-}, config: InitProviderConfiguration, abortSignal: AbortSignal): Promise<Result<O>>;
-export default generate;

package/dist/generation/initProvider.d.ts

@@ -1,20 +0,0 @@
-import type Provider from './provider';
-import { OutputKind, type Output } from './provider';
-import { InitProviderConfiguration, Options } from './types';
-import { BuilderRenderFunction } from '@cesdk/cesdk-js';
-type RenderBuilderFunctions = {
-    panel?: BuilderRenderFunction<any>;
-};
-/**
- * Initialize the provider. Based on the given options and configuration
- * it will register panels and components that is used to render
- * the provider in the UI.
- *
- * @param provider The provider to initialize.
- * @param options The options to use for the provider.
- * @param config The configuration to use for the provider.
- */
-declare function initProvider<K extends OutputKind, I, O extends Output>(provider: Provider<K, I, O>, options: Options, config: InitProviderConfiguration): Promise<{
-    renderBuilderFunctions?: RenderBuilderFunctions;
-}>;
-export default initProvider;

package/dist/generation/middleware/loggingMiddleware.d.ts

@@ -1,4 +0,0 @@
-import { Output } from '../provider';
-import { Middleware } from './middleware';
-declare function loggingMiddleware<I, O extends Output>(): Middleware<I, O>;
-export default loggingMiddleware;

package/dist/generation/quickAction/common/QuickActionBaseButton.d.ts

@@ -1,11 +0,0 @@
-import { ButtonOptions } from '@cesdk/cesdk-js';
-import { Output, QuickAction, QuickActionContext } from '../../provider';
-/**
- * Quick action base for quick actions to open a panel.
- */
-declare function QuickActionBaseButton<I, O extends Output>(options: {
-    buttonOptions?: ButtonOptions;
-    quickAction: Omit<QuickAction<I, O>, 'render' | 'renderExpanded'>;
-    onClick: (context: QuickActionContext<I, O>) => Promise<void>;
-}): QuickAction<I, O>;
-export default QuickActionBaseButton;

package/dist/generation/quickAction/common/QuickActionBaseLibrary.d.ts

@@ -1,23 +0,0 @@
-import CreativeEditorSDK, { AssetResult, ButtonOptions } from '@cesdk/cesdk-js';
-import { Output, QuickAction, QuickActionContext } from '../../provider';
-/**
- * Quick action base for quick actions that require a selection of items
- * from a library.
- */
-declare function QuickActionBaseLibrary<I, O extends Output>(options: {
-    cesdk: CreativeEditorSDK;
-    entries: string[];
-    buttonOptions?: ButtonOptions;
-    quickAction: Omit<QuickAction<I, O>, 'render' | 'renderExpanded'>;
-    mapInput?: (input: {
-        assetResult: AssetResult;
-        uri: string;
-        blockId: number;
-    }) => I;
-    onApply?: (options: {
-        assetResult: AssetResult;
-        uri: string;
-        blockId: number;
-    }, context: QuickActionContext<I, O>) => Promise<O>;
-}): QuickAction<I, O>;
-export default QuickActionBaseLibrary;