feat(embed): add shared embed runtime

packages/core/src/services/instance/__tests__/instance.service.spec.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import type { Nullable } from '../../../shared/types';
 import type { IWorkbookData } from '../../../sheets/typedef';
 import type { Workbook } from '../../../sheets/workbook';
 import type { IDocumentData } from '../../../types/interfaces/i-document-data';
@@ -217,4 +218,23 @@ describe('UniverInstanceService', () => {
         expect(service.getAllUnitsForType<MockBoardUnit>(UniverInstanceType.UNIVER_BOARD)).toEqual([board]);
         expect(service.getUnitType('board-unit')).toBe(UniverInstanceType.UNIVER_BOARD);
     });
+
+    it('does not rebroadcast unchanged current or focused units', () => {
+        const workbook = service.createUnit<Partial<IWorkbookData>, WorkbookModel>(UniverInstanceType.UNIVER_SHEET, createWorkbookData());
+        const currentIds: Array<string | null> = [];
+        const focusedIds: Array<Nullable<string>> = [];
+        service.getCurrentTypeOfUnit$<WorkbookModel>(UniverInstanceType.UNIVER_SHEET).subscribe((unit) => {
+            currentIds.push(unit?.getUnitId() ?? null);
+        });
+        service.focused$.subscribe((unitId) => {
+            focusedIds.push(unitId);
+        });
+
+        service.setCurrentUnitForType(workbook.getUnitId());
+        service.focusUnit(workbook.getUnitId());
+        service.focusUnit(workbook.getUnitId());
+
+        expect(currentIds).toEqual([workbook.getUnitId()]);
+        expect(focusedIds).toEqual([null, workbook.getUnitId()]);
+    });
 });

packages/core/src/services/instance/instance.service.ts

@@ -38,6 +38,28 @@ export interface ICreateUnitOptions {
      * @default true
      */
     makeCurrent?: boolean;
+    /**
+     * If product UI render services should skip their default main-canvas render
+     * creation. Embedded units create their render explicitly into a host-owned
+     * container instead.
+     *
+     * @default false
+     */
+    skipAutoRender?: boolean;
+    /**
+     * If render services should create the render unit as an embedded/non-main
+     * render. Embedded renders are mounted explicitly by a host container and
+     * must not mutate global workbench state while resolving their local view.
+     *
+     * @default false
+     */
+    embeddedRender?: boolean;
+    /**
+     * Optional parent injector for an embedded render unit. Render modules will
+     * resolve their dependencies from this injector before falling back to the
+     * root injector.
+     */
+    renderParentInjector?: Injector;
 }
 
 interface ICreateUnitEvent<T extends UnitModel = UnitModel> {
@@ -84,6 +106,8 @@ export interface IUniverInstanceService {
 
     /** Create a unit with snapshot info. */
     createUnit<T, U extends UnitModel>(type: UniverInstanceType, data: Partial<T>, options?: ICreateUnitOptions): U;
+    /** Get the options originally used to create a unit. */
+    getUnitCreateOptions(unitId: string): Nullable<ICreateUnitOptions>;
     /** Dispose a unit  */
     disposeUnit(unitId: string): boolean;
 
@@ -103,6 +127,7 @@ export interface IUniverInstanceService {
 export const IUniverInstanceService = createIdentifier<IUniverInstanceService>('univer.current');
 export class UniverInstanceService extends Disposable implements IUniverInstanceService {
     private readonly _unitsByType = new Map<UniverInstanceType, UnitModel[]>();
+    private readonly _unitCreateOptions = new Map<string, ICreateUnitOptions>();
 
     constructor(
         @Inject(Injector) private readonly _injector: Injector,
@@ -122,6 +147,7 @@ export class UniverInstanceService extends Disposable implements IUniverInstance
         this._currentUnits.forEach((unit) => unit?.dispose());
         this._currentUnits.clear();
         this._unitsByType.clear();
+        this._unitCreateOptions.clear();
     }
 
     private _createHandler!: (
@@ -169,6 +195,9 @@ export class UniverInstanceService extends Disposable implements IUniverInstance
     setCurrentUnitForType(unitId: string): void {
         const result = this._getUnitById(unitId);
         if (!result) throw new Error(`[UniverInstanceService]: no document with unitId ${unitId}!`);
+        if (this._currentUnits.get(result[1]) === result[0]) {
+            return;
+        }
 
         this._currentUnits.set(result[1], result[0]);
         this._currentUnits$.next(this._currentUnits);
@@ -202,6 +231,9 @@ export class UniverInstanceService extends Disposable implements IUniverInstance
         }
 
         units.push(unit);
+        if (options) {
+            this._unitCreateOptions.set(newUnitId, { ...options });
+        }
         this._unitAdded$.next({ unit, options });
 
         if (options?.makeCurrent ?? true) {
@@ -221,6 +253,10 @@ export class UniverInstanceService extends Disposable implements IUniverInstance
         return unit;
     }
 
+    getUnitCreateOptions(unitId: string): Nullable<ICreateUnitOptions> {
+        return this._unitCreateOptions.get(unitId) ?? null;
+    }
+
     getUniverSheetInstance(unitId: string): Nullable<Workbook> {
         return this.getUnit<Workbook>(unitId, UniverInstanceType.UNIVER_SHEET);
     }
@@ -251,6 +287,10 @@ export class UniverInstanceService extends Disposable implements IUniverInstance
     }
 
     focusUnit(id: string | null): void {
+        if (this._focused$.getValue() === id) {
+            return;
+        }
+
         this._focused$.next(id);
 
         if (this.focused instanceof Workbook) {
@@ -308,6 +348,7 @@ export class UniverInstanceService extends Disposable implements IUniverInstance
         this._tryResetFocusOnRemoval(unitId);
 
         this._unitDisposed$.next(unit);
+        this._unitCreateOptions.delete(unitId);
 
         unit.dispose();
 

packages/core/src/services/resource-loader/__tests__/resource-loader.service.spec.ts

@@ -28,8 +28,10 @@ describe('ResourceLoaderService', () => {
     let sheetAdded$: Subject<unknown>;
     let docAdded$: Subject<unknown>;
     let slideAdded$: Subject<unknown>;
+    let baseAdded$: Subject<unknown>;
     let sheetDisposed$: Subject<unknown>;
     let docDisposed$: Subject<unknown>;
+    let baseDisposed$: Subject<unknown>;
     let slideDisposed$: Subject<unknown>;
     let resourceManagerService: {
         getAllResourceHooks: ReturnType<typeof vi.fn>;
@@ -50,8 +52,10 @@ describe('ResourceLoaderService', () => {
         sheetAdded$ = new Subject();
         docAdded$ = new Subject();
         slideAdded$ = new Subject();
+        baseAdded$ = new Subject();
         sheetDisposed$ = new Subject();
         docDisposed$ = new Subject();
+        baseDisposed$ = new Subject();
         slideDisposed$ = new Subject();
         resourceManagerService = {
             getAllResourceHooks: vi.fn(() => []),
@@ -65,11 +69,13 @@ describe('ResourceLoaderService', () => {
             getTypeOfUnitAdded$: vi.fn((type) => {
                 if (type === UniverInstanceType.UNIVER_SHEET) return sheetAdded$;
                 if (type === UniverInstanceType.UNIVER_DOC) return docAdded$;
+                if (type === UniverInstanceType.UNIVER_BASE) return baseAdded$;
                 return slideAdded$;
             }),
             getTypeOfUnitDisposed$: vi.fn((type) => {
                 if (type === UniverInstanceType.UNIVER_SHEET) return sheetDisposed$;
                 if (type === UniverInstanceType.UNIVER_DOC) return docDisposed$;
+                if (type === UniverInstanceType.UNIVER_BASE) return baseDisposed$;
                 return slideDisposed$;
             }),
             getUnit: vi.fn(),
@@ -109,6 +115,19 @@ describe('ResourceLoaderService', () => {
         expect(resourceManagerService.unloadResources).toHaveBeenCalledWith('book-1', UniverInstanceType.UNIVER_SHEET);
     });
 
+    it('loads resources when a base unit is added and unloads them when disposed', () => {
+        const base = {
+            getUnitId: () => 'base-1',
+            getSnapshot: () => ({ resources: [{ name: 'base-plugin', data: '{}' }] }),
+        };
+
+        baseAdded$.next({ unit: base });
+        baseDisposed$.next(base);
+
+        expect(resourceManagerService.loadResources).toHaveBeenCalledWith('base-1', [{ name: 'base-plugin', data: '{}' }]);
+        expect(resourceManagerService.unloadResources).toHaveBeenCalledWith('base-1', UniverInstanceType.UNIVER_BASE);
+    });
+
     it('saves a unit snapshot with current plugin resources', () => {
         univerInstanceService.getUnit.mockReturnValue({
             type: UniverInstanceType.UNIVER_SHEET,

packages/core/src/services/resource-loader/resource-loader.service.ts

@@ -84,6 +84,12 @@ export class ResourceLoaderService extends Disposable implements IResourceLoader
                         });
                         break;
                     }
+                    case UniverInstanceType.UNIVER_BASE: {
+                        this._univerInstanceService.getAllUnitsForType<UnitModel<{ resources?: IResources }>>(UniverInstanceType.UNIVER_BASE).forEach((base) => {
+                            loadHookResource(hook, base.getUnitId(), base.getSnapshot().resources, 'Base');
+                        });
+                        break;
+                    }
                 }
             });
         };
@@ -121,6 +127,12 @@ export class ResourceLoaderService extends Disposable implements IResourceLoader
             })
         );
 
+        this.disposeWithMe(
+            this._univerInstanceService.getTypeOfUnitAdded$<UnitModel<{ resources?: IResources }>>(UniverInstanceType.UNIVER_BASE).subscribe((event) => {
+                const { unit: base } = event;
+                this._resourceManagerService.loadResources(base.getUnitId(), base.getSnapshot().resources);
+            })
+        );
         this.disposeWithMe(
             this._univerInstanceService.getTypeOfUnitDisposed$<Workbook>(UniverInstanceType.UNIVER_SHEET).subscribe((workbook) => {
                 this._resourceManagerService.unloadResources(workbook.getUnitId(), UniverInstanceType.UNIVER_SHEET);
@@ -132,6 +144,11 @@ export class ResourceLoaderService extends Disposable implements IResourceLoader
                 this._resourceManagerService.unloadResources(doc.getUnitId(), UniverInstanceType.UNIVER_DOC);
             })
         );
+        this.disposeWithMe(
+            this._univerInstanceService.getTypeOfUnitDisposed$<UnitModel<{ resources?: IResources }>>(UniverInstanceType.UNIVER_BASE).subscribe((base) => {
+                this._resourceManagerService.unloadResources(base.getUnitId(), UniverInstanceType.UNIVER_BASE);
+            })
+        );
         this.disposeWithMe(
             this._univerInstanceService.getTypeOfUnitDisposed$<UnitModel>(UniverInstanceType.UNIVER_SLIDE).subscribe((slide) => {
                 this._resourceManagerService.unloadResources(slide.getUnitId(), UniverInstanceType.UNIVER_SLIDE);

packages/core/src/services/resource-manager/type.ts

@@ -21,7 +21,7 @@ import { createIdentifier } from '../../common/di';
 
 export type IResources = Array<{ id?: string; name: string; data: string }>;
 
-type IBusinessName = 'SHEET' | 'DOC' | 'SLIDE';
+type IBusinessName = 'SHEET' | 'DOC' | 'SLIDE' | 'BASE' | 'UNIVER';
 export type IResourceName = `${IBusinessName}_${string}_PLUGIN`;
 export interface IResourceHook<T = any> {
     pluginName: IResourceName;

packages/core/src/types/interfaces/i-drawing.ts

@@ -84,6 +84,10 @@ export enum DrawingTypeEnum {
      * Dom element, allows inserting HTML elements as floating objects into the document
      */
     DRAWING_DOM = 8,
+    /**
+     * Block element, allows host products to place embeddable unit-backed blocks as drawing objects.
+     */
+    DRAWING_BLOCK = 9,
 }
 
 export type DrawingType = DrawingTypeEnum | number;