@univerjs-pro/engine-shape 1.0.0-alpha.8 → 1.0.0-beta.1

package/lib/types/facade/f-connector-shape.d.ts

@@ -20,7 +20,7 @@ import { FShape } from './f-shape';
  * const fConnectorShape = fDocument.insertShape({
  *   shapeType: univerAPI.Enum.ShapeTypeEnum.StraightConnector1,
  *   placement: {
- *     wrappingStyle: univerAPI.Enum.DocsShapeWrappingStyle.WRAP_SQUARE,
+ *     wrappingStyle: univerAPI.Enum.TextWrappingStyle.WRAP_SQUARE,
  *     anchor: {
  *       paragraphId: paragraph.getId(),
  *       segmentId: paragraph.getSegmentId(),

package/lib/types/facade/f-shape-text.d.ts

@@ -38,7 +38,7 @@ export interface IShapeTextImageFillOptions {
  * const fShape = fDocument.insertShape({
  *   shapeType: univerAPI.Enum.ShapeTypeEnum.Rect,
  *   placement: {
- *     wrappingStyle: univerAPI.Enum.DocsShapeWrappingStyle.INLINE,
+ *     wrappingStyle: univerAPI.Enum.TextWrappingStyle.INLINE,
  *     anchor: {
  *       paragraphId: paragraph.getId(),
  *       segmentId: paragraph.getSegmentId(),

package/lib/types/facade/f-shape.d.ts

@@ -1,4 +1,4 @@
-import type { IBasicShapeData, ImageSourceTypeEnum, IPresetShapeConfig, IShapeAdjustItemResolved, IShapeData, IShapeHostAdapter, IShapeLineStyle, IShapeRef, IShapeRelationItem, IShapeSnapshot, IShapeTransform, IShapeUpdateInput, ShapeGradientTypeEnum, ShapeHostType, ShapeLineCapEnum, ShapeLineDashEnum, ShapeLineJoinEnum, ShapeTypeEnum } from '@univerjs-pro/engine-shape';
+import type { IBasicShapeData, IInsertSmartArtNodeOptions, ImageSourceTypeEnum, IMoveSmartArtNodeOptions, IPresetShapeConfig, IShapeAdjustItemResolved, IShapeData, IShapeHostAdapter, IShapeLineStyle, IShapePath, IShapeRef, IShapeRelationItem, IShapeSnapshot, IShapeTransform, IShapeUpdateInput, ISmartArtData, ISmartArtDataNode, ISmartArtPresentationShape, ShapeGradientTypeEnum, ShapeHostType, ShapeLineCapEnum, ShapeLineDashEnum, ShapeLineJoinEnum, ShapeTypeEnum, SmartArtDirectionEnum } from '@univerjs-pro/engine-shape';
 import type { Injector } from '@univerjs/core';
 import { IShapeHostAdapterRegistry, ShapeLineTypeEnum } from '@univerjs-pro/engine-shape';
 import { ICommandService } from '@univerjs/core';
@@ -24,6 +24,25 @@ export interface IShapeConnectionSite {
     /** Outward site angle in OOXML angle units (1/60000 degree). */
     ang: number;
 }
+/**
+ * A single SVG path accepted by `FShape.setCustomGeometryFromSvgPath()`.
+ *
+ * `pathData` is the value of an SVG `<path d="...">` attribute, not complete SVG markup or a data
+ * URL. Fill and stroke colors remain Shape styles; `fill` and `stroke` only control whether this
+ * geometry path participates in filling and stroking.
+ */
+export interface IShapeSvgPathGeometryOptions {
+    /** SVG `<path>` `d` attribute value. */
+    pathData: string;
+    /** Optional virtual SVG coordinate-space width. The path scales to the Shape width when set. */
+    width?: number;
+    /** Optional virtual SVG coordinate-space height. The path scales to the Shape height when set. */
+    height?: number;
+    /** Optional geometry fill mode. Use `'none'` for an open or stroke-only path. */
+    fill?: IShapePath['fill'];
+    /** Whether the Shape stroke is applied to this geometry path. */
+    stroke?: boolean;
+}
 /** Optional image-fill properties accepted by `FShape.setImageFill()`. */
 export type IShapeImageFillOptions = Pick<ShapeFill, 'imageFillMode' | 'imageOpacity' | 'imageRotateWithShape' | 'stretchFillRect' | 'srcRect' | 'imageTile'>;
 /**
@@ -45,7 +64,7 @@ export type IShapeImageFillOptions = Pick<ShapeFill, 'imageFillMode' | 'imageOpa
  * const fShape = fDocument.insertShape({
  *   shapeType: univerAPI.Enum.ShapeTypeEnum.Rect,
  *   placement: {
- *     wrappingStyle: univerAPI.Enum.DocsShapeWrappingStyle.INLINE,
+ *     wrappingStyle: univerAPI.Enum.TextWrappingStyle.INLINE,
  *     anchor: {
  *       paragraphId: paragraph.getId(),
  *       segmentId: paragraph.getSegmentId(),
@@ -182,6 +201,32 @@ export declare class FShape extends FBase {
      * ```
      */
     getShapeData(): IShapeData | null;
+    /** Returns whether this Shape is a SmartArt composite. */
+    isSmartArt(): boolean;
+    /** Returns a detached copy of the normalized SmartArt structure. */
+    getSmartArtData(): ISmartArtData | null;
+    /** Replaces the complete normalized SmartArt structure through the host Shape command. */
+    setSmartArtData(data: ISmartArtData): this;
+    /** Inserts one logical node into the SmartArt tree. */
+    insertSmartArtNode(options: IInsertSmartArtNodeOptions): this;
+    /** Deletes a logical SmartArt node and its subtree. */
+    deleteSmartArtNode(nodeId: string): this;
+    /** Moves a logical SmartArt node without changing its stable identity. */
+    moveSmartArtNode(options: IMoveSmartArtNodeOptions): this;
+    /** Promotes a logical SmartArt node by one hierarchy level. */
+    promoteSmartArtNode(nodeId: string): this;
+    /** Demotes a logical SmartArt node below its preceding sibling. */
+    demoteSmartArtNode(nodeId: string): this;
+    /** Updates Text Pane content or the assistant/content role of one logical node. */
+    updateSmartArtNode(nodeId: string, update: Partial<Pick<ISmartArtDataNode, 'fontSizeMode' | 'role' | 'text'>>): this;
+    /** Sets the SmartArt left-to-right or right-to-left direction. */
+    setSmartArtDirection(direction: SmartArtDirectionEnum): this;
+    /** Switches the SmartArt layout while retaining the logical content tree. */
+    setSmartArtLayout(id: string): this;
+    /** Updates one independently editable presentation Shape inside the SmartArt composite. */
+    updateSmartArtPresentationShape(presentationShapeId: string, update: Partial<Pick<ISmartArtPresentationShape, 'shapeData' | 'transform'>>): this;
+    /** Converts SmartArt to host-native ordinary Shapes while preserving one undo step. */
+    convertSmartArtToShapes(): FShape[];
     /**
      * Returns a detached snapshot of the Shape and its host identity.
      * @returns {IShapeSnapshot | null} A detached snapshot of the Shape and its host identity, or `null` when the Shape is unavailable.
@@ -392,6 +437,59 @@ export declare class FShape extends FBase {
      * ```
      */
     setCustomGeometry(customGeometry: IPresetShapeConfig): this;
+    /**
+     * Replaces this Shape's geometry with one SVG path.
+     *
+     * Use this method when the source is an SVG `<path>` `d` attribute. Do not pass complete
+     * `<svg>`/`<path>` markup, a data URL, CSS, transforms, fill colors, or stroke colors in
+     * `options.pathData`. Configure visual styles with Shape facade methods such as
+     * `setSolidFill()`, `setNoneFill()`, and `setStroke()`.
+     *
+     * All standard SVG path commands are supported: `M/m`, `L/l`, `H/h`, `V/v`, `C/c`, `S/s`,
+     * `Q/q`, `T/t`, `A/a`, and `Z/z`. Relative commands and repeated coordinate groups are
+     * converted to absolute engine-shape commands. SVG arcs are converted to cubic Bézier segments
+     * instead of being misinterpreted as engine-shape's semantically different OOXML `A` command.
+     *
+     * Parsing finishes before the host Shape is updated. Invalid or unsupported path data throws a
+     * `SyntaxError` and leaves the existing Shape geometry unchanged.
+     *
+     * @param {IShapeSvgPathGeometryOptions} options SVG path geometry and optional virtual bounds.
+     * @returns {FShape} This Shape facade for chaining.
+     *
+     * @example Board — executable with `univer execute`
+     * ```ts
+     * const board = univerAPI.getActiveBoard();
+     * if (!board) throw new Error('No active board');
+     *
+     * const shape = board.insertShape({
+     *   shapeType: univerAPI.Enum.ShapeTypeEnum.Rect,
+     *   transform: { left: 300, top: 100, width: 160, height: 200 },
+     * });
+     * if (!shape) throw new Error('Cannot insert shape');
+     *
+     * shape
+     *   .setCustomGeometryFromSvgPath({
+     *     // This is only the value of <path d="...">.
+     *     pathData: 'M 50,10 C 34,20 24,64 22,92 L 78,92 C 76,64 66,20 50,10 Z',
+     *     width: 100,
+     *     height: 100,
+     *     fill: 'none',
+     *     stroke: true,
+     *   })
+     *   .setNoneFill()
+     *   .setStroke({
+     *     lineStrokeType: univerAPI.Enum.ShapeLineTypeEnum.SolidLine,
+     *     color: '#F0509B',
+     *     width: 3,
+     *   });
+     *
+     * return {
+     *   id: shape.getId(),
+     *   pathCount: shape.getCustomGeometry()?.pathLst?.length ?? 0,
+     * };
+     * ```
+     */
+    setCustomGeometryFromSvgPath(options: IShapeSvgPathGeometryOptions): this;
     /**
      * Returns the sites where Connector endpoints can attach to this Shape.
      * Coordinates are local to the unrotated Shape bounds. Shapes without
@@ -659,8 +757,20 @@ export declare class FShape extends FBase {
      * ```
      */
     sendToBack(): this;
+    /**
+     * Moves the Shape to a zero-based index in its host's persisted drawing order.
+     * The host clamps an out-of-range index to its nearest valid position.
+     * @param {number} index The zero-based target order index.
+     * @returns {FShape} This Shape facade for chaining.
+     * @example
+     * ```ts
+     * fShape.setZOrder(2);
+     * ```
+     */
+    setZOrder(index: number): this;
     protected _getAdapter(): IShapeHostAdapter | null;
     private _patchShapeData;
+    private _updateSmartArt;
     private _patchStroke;
     private _getSnapshot;
     private _getGeometryModel;

package/lib/types/facade/index.d.ts

@@ -1,6 +1,6 @@
 import './f-enum';
 export { FConnectorShape } from './f-connector-shape';
 export { FShape } from './f-shape';
-export type { IShapeConnectionSite, IShapeGradientStop, IShapeImageFillOptions } from './f-shape';
+export type { IShapeConnectionSite, IShapeGradientStop, IShapeImageFillOptions, IShapeSvgPathGeometryOptions, } from './f-shape';
 export { FShapeText } from './f-shape-text';
 export type { IShapeTextImageFillOptions } from './f-shape-text';

package/lib/types/index.d.ts

@@ -1,22 +1,37 @@
 export { BasicShapeModel as ShapeModel } from '../src/models/shape-model';
 export { BaseShapeRenderModel } from '../src/render-engine/shape-render-model';
-export { ImageFillModeEnum, ImageSourceTypeEnum, ShapeArrowSizeEnum, ShapeArrowTypeEnum, ShapeFillEnum, ShapeGradientTypeEnum, ShapeLineCapEnum, ShapeLineDashEnum, ShapeLineJoinEnum, ShapeLineTypeEnum, ShapeOperatorEnum, ShapePresetShadowValEnum, ShapeRenderModeEnum, ShapeSketchTypeEnum, ShapeTypeEnum, } from '../src/shape-enum';
-export type { IBasicShapeData, IConnectorLayoutResult, IConnectPointInfo, ICustomShapeTextData, ICxnShapeData, IDrawingRect, IGdContext, ILineType, IPathCommand, IPresetShapeConfig, IShapeAdjustItemResolved, IShapeData, IShapeFormulaBinding, IShapeJSONData, IShapeLineStyle, IShapePath, IShapePoint, IShapePointWithAdjName, IShapeRect, IShapeRelation, IShapeRelationItem, IShapeText, IShapeTextBodyBehavior, IShapeTextBoxOptions, IShapeTextData, IShapeTextDataModel, IShapeTextRectPadding, ShapeTextHorizontalAnchor, } from '../src/shape-type';
+export { ImageFillModeEnum, ImageSourceTypeEnum, ShapeArrowSizeEnum, ShapeArrowTypeEnum, ShapeBevelPresetEnum, ShapeCameraPresetEnum, ShapeFillEnum, ShapeGradientTypeEnum, ShapeLightRigDirectionEnum, ShapeLightRigPresetEnum, ShapeLineCapEnum, ShapeLineDashEnum, ShapeLineJoinEnum, ShapeLineTypeEnum, ShapeMaterialPresetEnum, ShapeOperatorEnum, ShapePresetShadowValEnum, ShapeRenderModeEnum, ShapeSketchTypeEnum, ShapeTypeEnum, } from '../src/shape-enum';
+export type { IBasicShapeData, IConnectorLayoutResult, IConnectPointInfo, ICustomShapeTextData, ICxnShapeData, IDrawingRect, IGdContext, ILineType, IPathCommand, IPresetShapeConfig, IShape3D, IShape3DRotation, IShape3DVector, IShapeAdjustItemResolved, IShapeData, IShapeFormulaBinding, IShapeJSONData, IShapeLineStyle, IShapePath, IShapePoint, IShapePointWithAdjName, IShapeRect, IShapeRelation, IShapeRelationItem, IShapeScene3D, IShapeText, IShapeTextBodyBehavior, IShapeTextBoxOptions, IShapeTextData, IShapeTextDataModel, IShapeTextRectPadding, ISmartArtData, ISmartArtDataNode, ISmartArtEditCapabilities, ISmartArtPresentationShape, ISmartArtPresentationTextBinding, ISmartArtShapeData, ISmartArtTransform, ShapeTextHorizontalAnchor, } from '../src/shape-type';
 export { ShapeTextAutoFitType, ShapeTextDirection, ShapeTextWrapType } from '../src/shape-type';
 export { applyShapeTextBoxOptions, resolveShapeTextBodyBehavior, resolveShapeTextBoxOptions, shouldUseFullShapeTextRectForAutoFit, } from '../src/utils/shape-text-behavior.util';
 export type { IResolvedShapeTextBoxOptions } from '../src/utils/shape-text-behavior.util';
 export { UniverShapePlugin } from './plugin';
 export { computeConnectorRouteLayout, getBasicShapeRotateBound, routeConnectorLineShape, } from './render-engine/connector-points-util';
+export { DEFAULT_SHAPE_BEVEL_EXTENT, getShape3DBounds, isShape3DProjectiveScene, projectShape3DPoint, projectShape3DRect, renderProjectedShapeRect, resolveShape3DGlyphRenderPlan, resolveShapeBevelExtent, shadeShape3DColor, } from './render-engine/shape-3d-renderer';
+export type { IShape3DGlyphRenderPlan, IShape3DProjectedPoint, IShape3DProjectedQuad, } from './render-engine/shape-3d-renderer';
 export { ConnectorShapeHostAdapter } from './services/connector-shape-host-adapter';
 export { IConnectorShapeHostAdapter } from './services/connector-shape-host-adapter.service';
 export type { IConnectorArrow, IConnectorEndpoint, IConnectorShapeSnapshot, } from './services/connector-shape-host-adapter.service';
 export { canApplyShapeFormulaLastValue, IShapeHostAdapterRegistry, isShapeHostType, ShapeHostAdapterRegistry, } from './services/shape-host-adapter.service';
-export type { IShapeCreateInput, IShapeFormulaLastValueGuard, IShapeHostAdapter, IShapeHostChange, IShapeHostChangeStream, IShapeRef, IShapeScope, IShapeSnapshot, IShapeTransform, IShapeUpdateInput, ShapeHostType, } from './services/shape-host-adapter.service';
+export type { IShapeCreateInput, IShapeFormulaLastValueGuard, IShapeHostAdapter, IShapeHostAdapterRegistryChange, IShapeHostAdapterRegistryChangeStream, IShapeHostChange, IShapeHostChangeStream, IShapeRef, IShapeScope, IShapeSnapshot, IShapeTransform, IShapeUpdateInput, ShapeHostType, } from './services/shape-host-adapter.service';
 export { ShapeDefaultConfig } from './shape-default';
 export { resolveShapeDefaultInsertSize } from './shape-default-size';
+export { applySmartArtColorStyle, SMART_ART_COLOR_STYLE_CATALOG } from './smart-art/smart-art-color-style';
+export type { ISmartArtColorStyleCatalogItem, SmartArtColorStyleSection } from './smart-art/smart-art-color-style';
+export { SmartArtCategoryEnum, SmartArtDirectionEnum, SmartArtInsertPositionEnum, SmartArtNodeRoleEnum, SmartArtPresentationShapeRoleEnum, SmartArtPresentationTextSourceEnum, SmartArtTextFontSizeModeEnum, } from './smart-art/smart-art-enum';
+export { applySmartArtLayout, createSmartArtDataFromLayout } from './smart-art/smart-art-layout-template';
+export type { ISmartArtLayoutTemplate } from './smart-art/smart-art-layout-template';
+export { convertSmartArtToShapes, deleteSmartArtNode, demoteSmartArtNode, insertSmartArtNode, isSmartArtShapeData, moveSmartArtNode, promoteSmartArtNode, readSmartArtTextContent, replaceSmartArtTextContent, resetSmartArtTextFontSizes, resolveSmartArtPresentationNodeIdAtTextOffset, resolveSmartArtPresentationShapeData, resolveSmartArtPresentationShapeIdForNode, resolveSmartArtPresentationTextBindings, setSmartArtDirection, setSmartArtLayout, updateSmartArtNode, updateSmartArtPresentationShape, updateSmartArtPresentationText, validateSmartArtData, } from './smart-art/smart-art-model';
+export type { IConvertedSmartArtShape, IInsertSmartArtNodeOptions, IMoveSmartArtNodeOptions, IUpdateSmartArtPresentationTextOptions, } from './smart-art/smart-art-model';
+export { applySmartArtOperation, SmartArtOperationTypeEnum } from './smart-art/smart-art-operation';
+export type { SmartArtOperation } from './smart-art/smart-art-operation';
+export { applySmartArtQuickStyle, SMART_ART_QUICK_STYLE_CATALOG } from './smart-art/smart-art-quick-style';
+export type { ISmartArtQuickStyleCatalogItem, SmartArtQuickStyleSection } from './smart-art/smart-art-quick-style';
+export { resolveSmartArtPresentationTransform } from './smart-art/smart-art-transform';
 export { ConnectorCoordinateTransform } from './util/connector-transform';
 export { createUniqueShapeName } from './util/shape-name';
 export { isConnectorShape, isCurvedConnectorShape, } from './util/shape-util';
 export { buildConnectorEndpointUpdate, buildConnectorRoutePointsUpdate, createFreeConnectorPointInfo, resolveConnectorRoutePoints, resolveShapeConnectionPoint, } from './utils/connector.util';
 export { applyDocumentToShapeText, applyRichTextToShapeText, applyShapeTextAlignment, applyShapeTextStyle, applyTextToShapeText, normalizeShapeTextData, shapeTextToRichTextValue, } from './utils/shape-text-converter';
 export type { IShapeTextAlignmentOptions } from './utils/shape-text-converter';
+export { parseSvgPathData } from './utils/svg-path-data';

package/lib/types/models/shape-model.d.ts

@@ -1,8 +1,7 @@
 import type { IBoundRectNoAngle } from '@univerjs/engine-render';
-import type { ShapeTypeEnum } from '../shape-enum';
 import type { IGdContext, IPresetShapeConfig, IShapeAdjustItemResolved, IShapeContextOptions, IShapeData, IShapeJSONData, IShapeModel, IShapePoint, IShapePointWithAdjName, IShapeRect, IShapeRelation, IShapeRelationItem, IShapeRenderParameters, IShapeTextData } from '../shape-type';
-import { BasicShapeEnum } from '../shape-enum';
-export declare function deepMerge<T extends Record<string, any>>(target: T, ...sources: Partial<T>[]): T;
+import { BasicShapeEnum, ShapeTypeEnum } from '../shape-enum';
+export declare function deepMerge<T extends object>(target: T, ...sources: Partial<T>[]): T;
 export declare class BasicShapeModel implements IShapeModel {
     protected _shapeType: ShapeTypeEnum;
     private readonly _id;
@@ -135,4 +134,6 @@ export declare class BasicShapeModel implements IShapeModel {
     toJSON(): IShapeJSONData;
     fromJSON(json: IShapeJSONData): void;
     private _createRenderModel;
+    private _renderSmartArtPresentationShapes;
+    private _getSmartArtDrawingBounds;
 }

package/lib/types/render-engine/shape-3d-renderer.d.ts

@@ -0,0 +1,91 @@
+import type { IBoundRectNoAngle } from '@univerjs/engine-render';
+import type { IShape3D, IShapeData, IShapeRect, IShapeRenderParameters, IShapeScene3D } from '../shape-type';
+import type { BaseShapeContext } from './base-shape-context';
+import type { BaseShapeRenderModel } from './shape-render-model';
+import { ShapeBevelPresetEnum, ShapeMaterialPresetEnum } from '../shape-enum';
+/** PowerPoint's implicit bevel extent, stored in the public model as points for OOXML round-trips. */
+export declare const DEFAULT_SHAPE_BEVEL_EXTENT = 6;
+export declare function resolveShapeBevelExtent(preset: ShapeBevelPresetEnum | undefined, extent: number | undefined): number;
+export declare function resolveProjectedFlatMaterialFactor(scene3d?: IShapeScene3D): number;
+interface IShape3DProjection {
+    x: number;
+    y: number;
+}
+interface IShapeBevelProfile {
+    /** Effective inset in units of the OOXML bevel width/height. */
+    widthScale: number;
+    heightScale: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+    inner?: number;
+    secondary?: number;
+    /** Fraction of the bevel occupied by the outer face in a compound profile. */
+    outerRatio?: number;
+    /** Reverses the inner face light response for concave profiles. */
+    innerTop?: number;
+    innerRight?: number;
+    innerBottom?: number;
+    innerLeft?: number;
+}
+export interface IShape3DProjectedPoint {
+    x: number;
+    y: number;
+    depth: number;
+}
+export interface IShape3DProjectedQuad {
+    topLeft: IShape3DProjectedPoint;
+    topRight: IShape3DProjectedPoint;
+    bottomRight: IShape3DProjectedPoint;
+    bottomLeft: IShape3DProjectedPoint;
+}
+export declare function applyShape3DCameraTransform(canvasContext: CanvasRenderingContext2D, rect: IShapeRect, scene3d?: IShapeScene3D): void;
+/** Stable renderer-level signature used by regression tests and cached glyph render plans. */
+export declare function resolveShapeBevelProfileSignature(preset?: ShapeBevelPresetEnum): string;
+/**
+ * Stable, fill-independent description of a PowerPoint bevel's light response.
+ * Consumers apply these signed alpha values over the current fill; presets never
+ * carry a source color of their own.
+ */
+export declare function resolveShapeBevelLightCurveSignature(preset?: ShapeBevelPresetEnum, scene3d?: IShapeScene3D, material?: ShapeMaterialPresetEnum): string;
+export interface IShape3DGlyphRenderPlan {
+    projection: IShape3DProjection;
+    layerCount: number;
+    extrusionColor: string;
+    extrusionInheritsFill: boolean;
+    extrusionOpacity: number;
+    lightFactor: number;
+    lightAngle: number;
+    materialGradientStops: ReadonlyArray<readonly [number, string]>;
+    bevel?: IShapeBevelProfile & {
+        width: number;
+        height: number;
+    };
+    contourWidth: number;
+    contourColor: string;
+}
+/** Resolves the Shape 2.5D semantics for a cached text-glyph alpha layer. */
+export declare function resolveShape3DGlyphRenderPlan(scene3d: IShapeScene3D | undefined, shape3d: IShape3D | undefined, baseColor?: string, sceneRect?: IShapeRect): IShape3DGlyphRenderPlan | undefined;
+export declare function shadeShape3DColor(color: string, factor: number): string;
+export declare function getShape3DCameraTransformedBounds(bounds: IBoundRectNoAngle, sceneRect: IShapeRect, scene3d?: IShapeScene3D): IBoundRectNoAngle;
+export declare function isShape3DProjectiveScene(scene3d?: IShapeScene3D): boolean;
+export declare function projectShape3DPoint(point: {
+    x: number;
+    y: number;
+    z?: number;
+}, sceneRect: IShapeRect, scene3d: IShapeScene3D): IShape3DProjectedPoint;
+export declare function projectShape3DRect(rect: IShapeRect, sceneRect: IShapeRect, scene3d: IShapeScene3D, z?: number): IShape3DProjectedQuad;
+export declare function renderProjectedShapeRect(canvasContext: CanvasRenderingContext2D, sceneRect: IShapeRect, rect: IShapeRect, scene3d: IShapeScene3D, shapeData: IShapeData, image?: HTMLImageElement): void;
+export declare function renderShape3D(canvasContext: CanvasRenderingContext2D, rect: IShapeRect, shapeContext: BaseShapeContext, shapeData: IShapeData, renderOption: IShapeRenderParameters, renderModel: BaseShapeRenderModel): void;
+export declare function renderShape3DFrontBevel(canvasContext: CanvasRenderingContext2D, rect: IShapeRect, shapeContext: BaseShapeContext, shapeData: IShapeData, renderOption: IShapeRenderParameters, renderModel: BaseShapeRenderModel): void;
+interface IMaterialSurfaceAdjustment {
+    add: number;
+    colorCurve?: readonly number[];
+    scale: number;
+}
+/** Continuous material response shared by preset and explicit DrawingML camera rotations. */
+export declare function resolveProjectedMaterialSurfaceAdjustment(material: ShapeMaterialPresetEnum, scene3d?: IShapeScene3D, shape3d?: IShape3D): IMaterialSurfaceAdjustment;
+export declare function getShape3DBounds(rect: IShapeRect, scene3d?: IShapeScene3D, shape3d?: IShape3D, sceneRect?: IShapeRect, strokeWidth?: number): IBoundRectNoAngle | undefined;
+export declare const DEFAULT_SHAPE_3D_SCENE: IShapeScene3D;
+export {};

package/lib/types/render-engine/shape-render-model.d.ts

@@ -5,6 +5,7 @@ export declare abstract class BaseShapeRenderModel {
     abstract readonly name: string;
     abstract readonly presetShapeConfig: IPresetShapeConfig;
     isLineShape(): boolean;
+    protected _isStrokeVisible(shapeData: IShapeData): boolean;
     getConnectorLinePoints(): IShapeGdContextKeyPoint[];
     /**
      * This method tests whether a point (pointX, pointY) hits any interactive parts of the shape,

package/lib/types/services/shape-host-adapter.service.d.ts

@@ -2,6 +2,7 @@ import type { IFormulaLastValue } from '@univerjs-pro/engine-formula';
 import type { IAccessor, IDisposable, IMutationInfo } from '@univerjs/core';
 import type { ShapeTypeEnum } from '../shape-enum';
 import type { IShapeData } from '../shape-type';
+import type { SmartArtOperation } from '../smart-art/smart-art-operation';
 import { UniverInstanceType } from '@univerjs/core';
 export type ShapeHostType = UniverInstanceType.UNIVER_SHEET | UniverInstanceType.UNIVER_DOC | UniverInstanceType.UNIVER_SLIDE | UniverInstanceType.UNIVER_BOARD;
 export declare function isShapeHostType(type: UniverInstanceType): type is ShapeHostType;
@@ -26,6 +27,15 @@ export interface IShapeHostChangeStream {
         unsubscribe(): void;
     };
 }
+export interface IShapeHostAdapterRegistryChange {
+    type: 'registered' | 'unregistered';
+    adapter: IShapeHostAdapter;
+}
+export interface IShapeHostAdapterRegistryChangeStream {
+    subscribe(listener: (change: IShapeHostAdapterRegistryChange) => void): {
+        unsubscribe(): void;
+    };
+}
 export interface IShapeTransform {
     /** Horizontal position in host coordinates. */
     left: number;
@@ -89,6 +99,8 @@ export interface IShapeUpdateInput {
     visible?: boolean;
     /** Canvas selectability to update. Omit to preserve the current value. */
     selectable?: boolean;
+    /** Semantic SmartArt edits resolved by the host's undoable command. */
+    smartArtOperations?: readonly SmartArtOperation[];
 }
 /**
  * Ephemeral compare-and-set guard carried by a derived Formula last-value mutation.
@@ -115,7 +127,14 @@ export interface IShapeHostAdapter {
      */
     listShapesInUnit?(unitId: string): IShapeSnapshot[];
     createShape(scope: IShapeScope, input: IShapeCreateInput): IShapeSnapshot | null;
+    /**
+     * Creates Shapes atomically and returns snapshots in input order.
+     * Implementations must return `null` without retaining partial changes when any input or the host command fails.
+     */
+    createShapes?(scope: IShapeScope, inputs: IShapeCreateInput[]): IShapeSnapshot[] | null;
     updateShape(ref: IShapeRef, input: IShapeUpdateInput): boolean;
+    /** Replaces one SmartArt composite with host-native ordinary Shapes in one undoable command. */
+    convertSmartArtToShapes?(ref: IShapeRef): IShapeSnapshot[] | null;
     /**
      * Builds the Host's existing Shape mutation for a successful Formula result.
      *
@@ -128,14 +147,21 @@ export interface IShapeHostAdapter {
     bringForward(ref: IShapeRef): boolean;
     sendBackward(ref: IShapeRef): boolean;
     sendToBack(ref: IShapeRef): boolean;
+    setZOrder(ref: IShapeRef, index: number): boolean;
 }
 export interface IShapeHostAdapterRegistry {
+    readonly adapterChanged$: IShapeHostAdapterRegistryChangeStream;
     register(adapter: IShapeHostAdapter): IDisposable;
     get(hostType: UniverInstanceType): IShapeHostAdapter | null;
+    list(): readonly IShapeHostAdapter[];
 }
 export declare const IShapeHostAdapterRegistry: import("@wendellhu/redi").IdentifierDecorator<IShapeHostAdapterRegistry>;
 export declare class ShapeHostAdapterRegistry implements IShapeHostAdapterRegistry {
     private readonly _adapters;
+    private readonly _adapterChangedListeners;
+    readonly adapterChanged$: IShapeHostAdapterRegistryChangeStream;
     register(adapter: IShapeHostAdapter): IDisposable;
     get(hostType: UniverInstanceType): IShapeHostAdapter | null;
+    list(): readonly IShapeHostAdapter[];
+    private _emitAdapterChanged;
 }

package/lib/types/shape-enum.d.ts

@@ -1,3 +1,6 @@
+import { ImageSourceType } from '@univerjs/core';
+export declare const ImageSourceTypeEnum: typeof ImageSourceType;
+export type ImageSourceTypeEnum = ImageSourceType;
 /**
  * Basic shape types
  */
@@ -79,9 +82,148 @@ export declare enum ShapePresetShadowValEnum {
     /** OOXML shdw20: Front Bottom Shadow, a front-facing shadow below the shape. */
     Shdw20 = "shdw20"
 }
+/** OOXML ST_PresetCameraType values used by `<a:camera prst="...">`. */
+export declare enum ShapeCameraPresetEnum {
+    LegacyObliqueTopLeft = "legacyObliqueTopLeft",
+    LegacyObliqueTop = "legacyObliqueTop",
+    LegacyObliqueTopRight = "legacyObliqueTopRight",
+    LegacyObliqueLeft = "legacyObliqueLeft",
+    LegacyObliqueFront = "legacyObliqueFront",
+    LegacyObliqueRight = "legacyObliqueRight",
+    LegacyObliqueBottomLeft = "legacyObliqueBottomLeft",
+    LegacyObliqueBottom = "legacyObliqueBottom",
+    LegacyObliqueBottomRight = "legacyObliqueBottomRight",
+    LegacyPerspectiveTopLeft = "legacyPerspectiveTopLeft",
+    LegacyPerspectiveTop = "legacyPerspectiveTop",
+    LegacyPerspectiveTopRight = "legacyPerspectiveTopRight",
+    LegacyPerspectiveLeft = "legacyPerspectiveLeft",
+    LegacyPerspectiveFront = "legacyPerspectiveFront",
+    LegacyPerspectiveRight = "legacyPerspectiveRight",
+    LegacyPerspectiveBottomLeft = "legacyPerspectiveBottomLeft",
+    LegacyPerspectiveBottom = "legacyPerspectiveBottom",
+    LegacyPerspectiveBottomRight = "legacyPerspectiveBottomRight",
+    OrthographicFront = "orthographicFront",
+    IsometricTopUp = "isometricTopUp",
+    IsometricTopDown = "isometricTopDown",
+    IsometricBottomUp = "isometricBottomUp",
+    IsometricBottomDown = "isometricBottomDown",
+    IsometricLeftUp = "isometricLeftUp",
+    IsometricLeftDown = "isometricLeftDown",
+    IsometricRightUp = "isometricRightUp",
+    IsometricRightDown = "isometricRightDown",
+    IsometricOffAxis1Left = "isometricOffAxis1Left",
+    IsometricOffAxis1Right = "isometricOffAxis1Right",
+    IsometricOffAxis1Top = "isometricOffAxis1Top",
+    IsometricOffAxis2Left = "isometricOffAxis2Left",
+    IsometricOffAxis2Right = "isometricOffAxis2Right",
+    IsometricOffAxis2Top = "isometricOffAxis2Top",
+    IsometricOffAxis3Left = "isometricOffAxis3Left",
+    IsometricOffAxis3Right = "isometricOffAxis3Right",
+    IsometricOffAxis3Bottom = "isometricOffAxis3Bottom",
+    IsometricOffAxis4Left = "isometricOffAxis4Left",
+    IsometricOffAxis4Right = "isometricOffAxis4Right",
+    IsometricOffAxis4Bottom = "isometricOffAxis4Bottom",
+    ObliqueTopLeft = "obliqueTopLeft",
+    ObliqueTop = "obliqueTop",
+    ObliqueTopRight = "obliqueTopRight",
+    ObliqueLeft = "obliqueLeft",
+    ObliqueRight = "obliqueRight",
+    ObliqueBottomLeft = "obliqueBottomLeft",
+    ObliqueBottom = "obliqueBottom",
+    ObliqueBottomRight = "obliqueBottomRight",
+    PerspectiveFront = "perspectiveFront",
+    PerspectiveLeft = "perspectiveLeft",
+    PerspectiveRight = "perspectiveRight",
+    PerspectiveAbove = "perspectiveAbove",
+    PerspectiveBelow = "perspectiveBelow",
+    PerspectiveAboveLeftFacing = "perspectiveAboveLeftFacing",
+    PerspectiveAboveRightFacing = "perspectiveAboveRightFacing",
+    PerspectiveContrastingLeftFacing = "perspectiveContrastingLeftFacing",
+    PerspectiveContrastingRightFacing = "perspectiveContrastingRightFacing",
+    PerspectiveHeroicLeftFacing = "perspectiveHeroicLeftFacing",
+    PerspectiveHeroicRightFacing = "perspectiveHeroicRightFacing",
+    PerspectiveHeroicExtremeLeftFacing = "perspectiveHeroicExtremeLeftFacing",
+    PerspectiveHeroicExtremeRightFacing = "perspectiveHeroicExtremeRightFacing",
+    PerspectiveRelaxed = "perspectiveRelaxed",
+    PerspectiveRelaxedModerately = "perspectiveRelaxedModerately"
+}
+/** OOXML ST_LightRigType values used by `<a:lightRig rig="...">`. */
+export declare enum ShapeLightRigPresetEnum {
+    LegacyFlat1 = "legacyFlat1",
+    LegacyFlat2 = "legacyFlat2",
+    LegacyFlat3 = "legacyFlat3",
+    LegacyFlat4 = "legacyFlat4",
+    LegacyNormal1 = "legacyNormal1",
+    LegacyNormal2 = "legacyNormal2",
+    LegacyNormal3 = "legacyNormal3",
+    LegacyNormal4 = "legacyNormal4",
+    LegacyHarsh1 = "legacyHarsh1",
+    LegacyHarsh2 = "legacyHarsh2",
+    LegacyHarsh3 = "legacyHarsh3",
+    LegacyHarsh4 = "legacyHarsh4",
+    ThreePoint = "threePt",
+    Balanced = "balanced",
+    Soft = "soft",
+    Harsh = "harsh",
+    Flood = "flood",
+    Contrasting = "contrasting",
+    Morning = "morning",
+    Sunrise = "sunrise",
+    Sunset = "sunset",
+    Chilly = "chilly",
+    Freezing = "freezing",
+    Flat = "flat",
+    TwoPoint = "twoPt",
+    Glow = "glow",
+    BrightRoom = "brightRoom"
+}
+/** OOXML ST_LightRigDirection values. */
+export declare enum ShapeLightRigDirectionEnum {
+    TopLeft = "tl",
+    Top = "t",
+    TopRight = "tr",
+    Left = "l",
+    Right = "r",
+    BottomLeft = "bl",
+    Bottom = "b",
+    BottomRight = "br"
+}
+/** OOXML ST_PresetMaterialType values used by `<a:sp3d prstMaterial="...">`. */
+export declare enum ShapeMaterialPresetEnum {
+    LegacyMatte = "legacyMatte",
+    LegacyPlastic = "legacyPlastic",
+    LegacyMetal = "legacyMetal",
+    LegacyWireframe = "legacyWireframe",
+    Matte = "matte",
+    Plastic = "plastic",
+    Metal = "metal",
+    WarmMatte = "warmMatte",
+    TranslucentPowder = "translucentPowder",
+    Powder = "powder",
+    DarkEdge = "dkEdge",
+    SoftEdge = "softEdge",
+    Clear = "clear",
+    Flat = "flat",
+    SoftMetal = "softmetal"
+}
+/** OOXML ST_BevelPresetType values used by `<a:bevelT>` and `<a:bevelB>`. */
+export declare enum ShapeBevelPresetEnum {
+    RelaxedInset = "relaxedInset",
+    Circle = "circle",
+    Slope = "slope",
+    Cross = "cross",
+    Angle = "angle",
+    SoftRound = "softRound",
+    Convex = "convex",
+    CoolSlant = "coolSlant",
+    Divot = "divot",
+    Riblet = "riblet",
+    HardEdge = "hardEdge",
+    ArtDeco = "artDeco"
+}
 /**
  * Shape fill type enum
- * Currently, PatternFill and PictureFill are not supported, but we define them for future use, if will be treat as Nofill currently.
+ * Shape fill types supported by the renderer.
  */
 export declare enum ShapeFillEnum {
     NoFill = 1,
@@ -136,6 +278,8 @@ export declare enum ShapeOperatorEnum {
 export declare enum ShapeTypeEnum {
     /** No rendered geometry; reserve this value for an explicitly empty shape. */
     None = "none",
+    /** SmartArt composite host. Its editable presentation shapes remain nested in `shapeData.smartArt`. */
+    SmartArt = "smartArt",
     /** Rectangle for generic process steps, cards, and diagram nodes. */
     Rect = "rect",
     /** Rounded rectangle for friendly process steps, states, and cards. */
@@ -572,23 +716,6 @@ export declare enum ShapeSketchTypeEnum {
     Freehand = 3,
     HandDrawn = 4
 }
-/**
- * The type of image data source
- */
-export declare enum ImageSourceTypeEnum {
-    /**
-     * The image source is a URL, for example: https://avatars.githubusercontent.com/u/61444807?s=48&v=4
-     */
-    URL = "URL",
-    /**
-     * The image source is a UUID, this ID is generated by the Univer image hosting service. For specific generation rules, please refer to the Univer image hosting service API documentation.
-     */
-    UUID = "UUID",
-    /**
-     * The image source is BASE64, for example: data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABQAAAALCAYAAAB7ZJ...
-     */
-    BASE64 = "BASE64"
-}
 /**
  * The image fill mode when ShapeFillEnum is PictureFill
  */