oasis-editor 0.0.24 → 0.0.26

package/dist/ui/OasisEditorEditor.d.ts

@@ -14,6 +14,9 @@ export interface OasisEditorEditorLayoutProps {
     style?: JSX.CSSProperties;
     readOnly?: boolean;
     showHorizontalRuler?: boolean;
+    zoomPercent?: Accessor<number>;
+    setZoomPercent?: (value: number) => void;
+    zoomFactor?: Accessor<number>;
 }
 export interface OasisEditorEditorOverlayProps {
     selectionBoxes: Accessor<SelectionBox[]>;

package/dist/ui/app/buildEditorViewProps.d.ts

@@ -19,6 +19,9 @@ export interface EditorViewPropsContext {
     viewportHeight: number | string | undefined;
     className: string | undefined;
     style: JSX.CSSProperties | undefined;
+    zoomPercent: Accessor<number>;
+    setZoomPercent: (value: number) => void;
+    zoomFactor: Accessor<number>;
     selectionBoxes: Accessor<SelectionBox[]>;
     commentHighlights: Accessor<CommentHighlightBox[]>;
     selectedImageBox: Accessor<SelectedImageBox | null>;

package/dist/ui/app/editorZoom.d.ts

@@ -0,0 +1,25 @@
+import { Accessor } from 'solid-js';
+
+export declare const ZOOM_MIN = 50;
+export declare const ZOOM_MAX = 200;
+export declare const ZOOM_STEP = 10;
+export declare const ZOOM_DEFAULT = 100;
+export declare function clampZoom(value: number): number;
+export interface EditorZoomController {
+    /** Current zoom level as a percentage (clamped to [ZOOM_MIN, ZOOM_MAX]). */
+    zoomPercent: Accessor<number>;
+    /** Set the zoom level (input is clamped). */
+    setZoomPercent: (value: number) => void;
+    /** Nudge the zoom level by `delta` percent (result is clamped). */
+    adjustZoom: (delta: number) => void;
+    /** Visual scale factor `z = zoomPercent / 100` applied to the document layer. */
+    zoomFactor: Accessor<number>;
+}
+/**
+ * Single source of truth for the document zoom. The factor `z` is the CSS
+ * `transform: scale(z)` applied to the shared `.oasis-editor-editor-scroll-content`
+ * layer (canvas + every overlay). Geometry consumers divide screen-space pointer
+ * coordinates by `z` to map back into the unscaled layout space the canvas draws
+ * in — see the coordinate contract in CanvasLayoutSnapshot.ts.
+ */
+export declare function createEditorZoom(initial?: number): EditorZoomController;

package/dist/ui/app/useCanvasSurfaceHitResolver.d.ts

@@ -8,6 +8,7 @@ export declare function createCanvasSurfaceHitResolver(deps: {
     viewportRef: Accessor<HTMLElement | null>;
     measuredBlockHeights: Accessor<Record<string, number>>;
     measuredParagraphLayouts: Accessor<Record<string, EditorLayoutParagraph>>;
+    zoomFactor: Accessor<number>;
 }): {
     resolveSurfaceHitAtPoint: (clientX: number, clientY: number, context?: {
         forDrag?: boolean;

package/dist/ui/app/useEditorInteractionWiring.d.ts

@@ -38,6 +38,7 @@ export interface EditorInteractionWiringContext {
     caretBox: NavigationParams["caretBox"];
     preferredColumnX: NavigationParams["preferredColumnX"];
     setPreferredColumnX: NavigationParams["setPreferredColumnX"];
+    zoomFactor: NavigationParams["zoomFactor"];
     resolveSurfaceHitAtPoint: TextDragParams["resolveSurfaceHitAtPoint"];
     resolvePositionAtSurfacePoint: TableDragParams["resolvePositionAtSurfacePoint"];
     tableOps: ReturnType<typeof createEditorTableOperations>;

package/dist/ui/canvas/CanvasDebug.d.ts

@@ -66,6 +66,8 @@ export interface CanvasDebugLayoutSnapshot {
             width: number;
             height: number;
         };
+        /** Set when the paragraph/cell is painted with a vertical-text transform. */
+        verticalMode?: CanvasSnapshotParagraph["verticalMode"];
     }>;
     inlineImages: Array<{
         paragraphId: string;
@@ -79,6 +81,19 @@ export interface CanvasDebugLayoutSnapshot {
         width: number;
         height: number;
     }>;
+    inlineTextBoxes: Array<{
+        paragraphId: string;
+        paragraphIndex: number;
+        zone: EditorEditingZone;
+        pageIndex: number;
+        startOffset: number;
+        endOffset: number;
+        left: number;
+        top: number;
+        width: number;
+        height: number;
+        rotation?: number;
+    }>;
     unsupportedRegions: Array<{
         pageIndex: number;
         zone: EditorEditingZone;

package/dist/ui/canvas/CanvasHitTestService.d.ts

@@ -44,6 +44,12 @@ export interface ResolveCanvasHitOptions {
     state: EditorState;
     clientX: number;
     clientY: number;
+    /**
+     * Visual zoom factor (CSS `transform: scale(z)`). Screen-space pointer coords
+     * are mapped into the snapshot's unscaled space by dividing the distance from
+     * the surface origin by `z`. Defaults to 1 (no zoom).
+     */
+    zoomFactor?: number;
     /**
      * "Pierce" mode (Alt+click): select the floating object directly under the
      * cursor even when it is painted behind the text (behindDoc). When false,

package/dist/ui/canvas/CanvasLayoutSnapshot.d.ts

@@ -145,5 +145,34 @@ export interface BuildCanvasLayoutSnapshotOptions {
     state: EditorState;
     measuredBlockHeights?: Record<string, number>;
     measuredParagraphLayouts?: Record<string, EditorLayoutParagraph>;
+    /**
+     * Visual zoom factor (CSS `transform: scale(z)`) applied to the surface. The
+     * snapshot is built in "screen-anchored local" space so it is invariant under
+     * zoom — see the coordinate contract documented on buildCanvasLayoutSnapshot.
+     * Defaults to 1 (no zoom).
+     */
+    zoomFactor?: number;
 }
+/**
+ * Coordinate contract ("screen-anchored local" space)
+ * ----------------------------------------------------
+ * The document layer (`.oasis-editor-editor-scroll-content`) is scaled with a
+ * CSS `transform: scale(z)` and `transform-origin: top left`, so the layer's
+ * local origin (0,0) maps to `surfaceRect.{left,top}` on screen and a child at
+ * screen distance `d` from that origin sits at local `d / z`.
+ *
+ * Every coordinate in this snapshot is emitted as `surfaceRect.origin +
+ * offsetLocal`, where `offsetLocal` is in unscaled (pre-transform) CSS px — the
+ * same units the canvas draws in and the same units overlays use inside the
+ * scaled layer. To achieve this we divide the only zoom-affected input (the page
+ * element's `getBoundingClientRect`, which already reflects the transform) by
+ * `z` relative to the surface origin; the model offsets added on top are already
+ * unscaled. The result is invariant under zoom.
+ *
+ * Consumers:
+ *  - Overlays (children of the scaled layer) use `value - surfaceRect` to get
+ *    `offsetLocal` and let the transform do the visual scaling — no change.
+ *  - Hit-testing receives screen-space pointer coords and converts them into
+ *    this space at the single entry point (resolveCanvasSurfaceHitAtPoint).
+ */
 export declare function buildCanvasLayoutSnapshot(options: BuildCanvasLayoutSnapshotOptions): CanvasLayoutSnapshot | null;

package/dist/ui/components/Ruler/HorizontalRuler.d.ts

@@ -7,5 +7,12 @@ export interface HorizontalRulerProps {
     toolbarHost: () => ToolbarHost;
     viewportRef: Accessor<HTMLDivElement | undefined>;
     readOnly: Accessor<boolean>;
+    /**
+     * Visual zoom factor `z`. The ruler lives *outside* the scaled document
+     * layer, so model-derived positions/sizes are rendered in screen px (× z) and
+     * pointer coordinates are mapped back to document px (÷ z). `pageLeft` is
+     * already measured in screen px from the scaled paper, so it is not scaled.
+     */
+    zoomFactor: Accessor<number>;
 }
 export declare function HorizontalRuler(props: HorizontalRulerProps): import("solid-js").JSX.Element;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oasis-editor",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "type": "module",
   "repository": {
     "type": "git",