@cesdk/engine 1.68.0-nightly.20260123 → 1.68.0-rc.0

package/.browserslistrc

@@ -0,0 +1,8 @@
+# NOTE: If you changed this file please remember to also update the content
+# for our CE.SDK browser support dialog component inside
+# `apps/cesdk_web/packages/cesdk/index.tsx` if necessary
+
+Firefox >= 115
+Safari >= 15.6
+Edge >= 114
+Chrome >= 114

package/angular/index.d.ts

@@ -0,0 +1,38 @@
+import * as i0 from '@angular/core';
+import { AfterViewInit, OnDestroy, OnChanges, ElementRef, SimpleChanges } from '@angular/core';
+import CreativeEditorSDK, { Configuration } from '@cesdk/cesdk-js';
+
+interface CreativeEditorError {
+    message: string;
+    cause?: unknown;
+}
+type CreativeEditorLoadingState = 'idle' | 'loading' | 'loaded' | 'error';
+declare class CreativeEditor implements AfterViewInit, OnDestroy, OnChanges {
+    containerRef: ElementRef<HTMLDivElement>;
+    config: Configuration;
+    init?: (cesdk: CreativeEditorSDK) => void | Promise<void>;
+    width: number | string;
+    height: number | string;
+    className?: string;
+    onLoadingStateChange?: (state: CreativeEditorLoadingState) => void;
+    onError?: (error: CreativeEditorError) => void;
+    private instance;
+    private loadingState;
+    private isInitializing;
+    ngAfterViewInit(): Promise<void>;
+    ngOnChanges(changes: SimpleChanges): Promise<void>;
+    ngOnDestroy(): void;
+    private handleLoadingStateChange;
+    private handleError;
+    private validateConfig;
+    private validateInit;
+    private initializeEditor;
+    private reinitializeEditor;
+    private destroyEditor;
+    getEditorInstance(): CreativeEditorSDK | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CreativeEditor, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CreativeEditor, "creative-editor", never, { "config": { "alias": "config"; "required": false; }; "init": { "alias": "init"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "className": { "alias": "className"; "required": false; }; "onLoadingStateChange": { "alias": "onLoadingStateChange"; "required": false; }; "onError": { "alias": "onError"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+export { CreativeEditor };
+export type { CreativeEditorError, CreativeEditorLoadingState };

package/angular/index.js

@@ -0,0 +1,146 @@
+import { CommonModule } from '@angular/common';
+import * as i0 from '@angular/core';
+import { Input, ViewChild, Component } from '@angular/core';
+
+class CreativeEditor {
+    containerRef;
+    config;
+    init;
+    width = '100%';
+    height = '100%';
+    className;
+    onLoadingStateChange;
+    onError;
+    instance = null;
+    loadingState = 'idle';
+    isInitializing = false;
+    async ngAfterViewInit() {
+        await this.initializeEditor();
+    }
+    async ngOnChanges(changes) {
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        if (changes['config'] && !changes['config'].firstChange) {
+            await this.reinitializeEditor();
+        }
+    }
+    ngOnDestroy() {
+        this.destroyEditor();
+    }
+    handleLoadingStateChange(state) {
+        this.loadingState = state;
+        this.onLoadingStateChange?.(state);
+    }
+    handleError(errorMessage, cause) {
+        const editorError = {
+            message: errorMessage,
+            cause,
+        };
+        this.handleLoadingStateChange('error');
+        this.onError?.(editorError);
+    }
+    validateConfig(cfg) {
+        if (!cfg || typeof cfg !== 'object') {
+            throw new Error('Configuration must be a valid object');
+        }
+    }
+    validateInit(initFn) {
+        if (initFn && typeof initFn !== 'function') {
+            throw new Error('Init must be a valid function');
+        }
+    }
+    async initializeEditor() {
+        if (this.isInitializing || this.loadingState !== 'idle' || this.instance) {
+            return;
+        }
+        this.isInitializing = true;
+        try {
+            this.handleLoadingStateChange('loading');
+            this.validateConfig(this.config);
+            this.validateInit(this.init);
+            const CreativeEditorSDKModule = (await import('@cesdk/cesdk-js')).default;
+            this.instance = await CreativeEditorSDKModule.create(this.containerRef.nativeElement, this.config);
+            this.handleLoadingStateChange('loaded');
+            if (this.init) {
+                try {
+                    await this.init(this.instance);
+                }
+                catch (initError) {
+                    this.handleError('Initialization function failed', initError);
+                }
+            }
+        }
+        catch (creationError) {
+            this.handleError('Failed to create Creative Editor SDK instance', creationError);
+        }
+        finally {
+            this.isInitializing = false;
+        }
+    }
+    async reinitializeEditor() {
+        this.destroyEditor();
+        await this.initializeEditor();
+    }
+    destroyEditor() {
+        if (this.instance) {
+            try {
+                this.instance.dispose();
+            }
+            catch (cleanupError) {
+                this.handleError('Error during CreativeEditor cleanup', cleanupError);
+            }
+            finally {
+                this.instance = null;
+                this.handleLoadingStateChange('idle');
+            }
+        }
+    }
+    getEditorInstance() {
+        return this.instance;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: CreativeEditor, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.2.4", type: CreativeEditor, isStandalone: true, selector: "creative-editor", inputs: { config: "config", init: "init", width: "width", height: "height", className: "className", onLoadingStateChange: "onLoadingStateChange", onError: "onError" }, viewQueries: [{ propertyName: "containerRef", first: true, predicate: ["cesdk_container"], descendants: true, static: true }], usesOnChanges: true, ngImport: i0, template: `
+    <div
+      #cesdk_container
+      [style.width]="width"
+      [style.height]="height"
+      [class]="className"
+      data-testid="creative-editor-container"
+    ></div>
+  `, isInline: true, styles: [":host{display:block;position:relative}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.2.4", ngImport: i0, type: CreativeEditor, decorators: [{
+            type: Component,
+            args: [{ selector: 'creative-editor', standalone: true, imports: [CommonModule], template: `
+    <div
+      #cesdk_container
+      [style.width]="width"
+      [style.height]="height"
+      [class]="className"
+      data-testid="creative-editor-container"
+    ></div>
+  `, styles: [":host{display:block;position:relative}\n"] }]
+        }], propDecorators: { containerRef: [{
+                type: ViewChild,
+                args: ['cesdk_container', { static: true }]
+            }], config: [{
+                type: Input
+            }], init: [{
+                type: Input
+            }], width: [{
+                type: Input
+            }], height: [{
+                type: Input
+            }], className: [{
+                type: Input
+            }], onLoadingStateChange: [{
+                type: Input
+            }], onError: [{
+                type: Input
+            }] } });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CreativeEditor };
+//# sourceMappingURL=cesdk-angular.mjs.map