@myoc/common 0.19.519 → 0.19.520

package/dist/types/excalidraw/components/App.d.ts

@@ -2,13 +2,14 @@ import React from "react";
 import { AppEventBus, type EXPORT_IMAGE_TYPES, Emitter, type EditorInterface, type StylesPanelMode } from "@excalidraw/common";
 import { FlowChartCreator, Scene, Store, type ElementUpdate, StoreDelta, type ApplyToOptions } from "@excalidraw/element";
 import { LinearElementEditor } from "@excalidraw/element/linearElementEditor";
-import type { ExcalidrawElement, NonDeleted, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
+import type { ExcalidrawElement, NonDeleted, FileId, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@excalidraw/element/types";
 import type { Mutable } from "@excalidraw/common/utility-types";
 import { ActionManager } from "../actions/manager";
 import { History } from "../history";
 import { Fonts } from "../fonts";
 import { type WritableAtom } from "../editor-jotai";
 import { Renderer } from "../scene/Renderer";
+import { type ScrollToContentOptions } from "../scroll";
 import { LaserTrails } from "../laserTrails";
 import { isOverScrollBars } from "../scene/scrollbars";
 import { LassoTrail } from "../lasso";
@@ -88,6 +89,10 @@ declare class App extends React.Component<AppProps, AppState> {
     };
     files: BinaryFiles;
     imageCache: AppClassProperties["imageCache"];
+    imageLoadingProgress: Map<FileId, number>;
+    imageLoadingProgressEmitter: Emitter<[]>;
+    imagePlaceholderUpdateEmitter: Emitter<[]>;
+    private imageTransitionPlaceholders;
     private iFrameRefs;
     /**
      * Indicates whether the embeddable's url has been validated for rendering.
@@ -387,33 +392,7 @@ declare class App extends React.Component<AppProps, AppState> {
         animate?: boolean;
         duration?: number;
     }) => void;
-    scrollToContent: (
-    /**
-     * target to scroll to
-     *
-     * - string - id of element or group, or url containing elementLink
-     * - ExcalidrawElement | ExcalidrawElement[] - element(s) objects
-     */
-    target?: string | ExcalidrawElement | readonly ExcalidrawElement[], opts?: ({
-        fitToContent?: boolean;
-        fitToViewport?: never;
-        viewportZoomFactor?: number;
-        animate?: boolean;
-        duration?: number;
-    } | {
-        fitToContent?: never;
-        fitToViewport?: boolean;
-        /** when fitToViewport=true, how much screen should the content cover,
-         * between 0.1 (10%) and 1 (100%)
-         */
-        viewportZoomFactor?: number;
-        animate?: boolean;
-        duration?: number;
-    }) & {
-        minZoom?: number;
-        maxZoom?: number;
-        canvasOffsets?: Offsets;
-    }) => void;
+    scrollToContent: (target?: string | ExcalidrawElement | readonly NonDeletedExcalidrawElement[], opts?: ScrollToContentOptions) => void;
     private maybeUnfollowRemoteUser;
     /** use when changing scrollX/scrollY/zoom based on user interaction */
     private translateCanvas;
@@ -425,6 +404,10 @@ declare class App extends React.Component<AppProps, AppState> {
      * NOTE if file already exists in editor state, the file data is not updated
      * */
     addFiles: ExcalidrawImperativeAPI["addFiles"];
+    addImagePlaceholder: ExcalidrawImperativeAPI["addImagePlaceholder"];
+    setImageLoadingProgress: ExcalidrawImperativeAPI["setImageLoadingProgress"];
+    private clearImageLoadingProgress;
+    private clearImageShapeCacheForFileId;
     private addMissingFiles;
     updateScene: <K extends keyof AppState>(sceneData: {
         elements?: SceneData["elements"];
@@ -555,6 +538,7 @@ declare class App extends React.Component<AppProps, AppState> {
     private newImagePlaceholder;
     private handleLinearElementOnPointerDown;
     private getCurrentItemRoundness;
+    private getCurrentItemStrokeWidth;
     private createGenericElementOnPointerDown;
     private createFrameElementOnPointerDown;
     private maybeCacheReferenceSnapPoints;

package/dist/types/excalidraw/components/ColorPicker/colorPickerUtils.d.ts

@@ -14,7 +14,7 @@ export declare const isCustomColor: ({ color, palette, }: {
 }) => boolean;
 export declare const getMostUsedCustomColors: (elements: readonly ExcalidrawElement[], type: "elementBackground" | "elementStroke", palette: ColorPaletteCustom) => string[];
 export type ActiveColorPickerSectionAtomType = "custom" | "baseColors" | "shades" | "hex" | null;
-export declare const activeColorPickerSectionAtom: import("jotai/vanilla/atom").PrimitiveAtom<ActiveColorPickerSectionAtomType> & {
+export declare const activeColorPickerSectionAtom: import("jotai").PrimitiveAtom<ActiveColorPickerSectionAtomType> & {
     init: ActiveColorPickerSectionAtomType;
 };
 export type ColorPickerType = "canvasBackground" | "elementBackground" | "elementStroke";

package/dist/types/excalidraw/components/ConvertElementTypePopup.d.ts

@@ -2,7 +2,7 @@ import type { ConvertibleTypes, ExcalidrawElement, ExcalidrawTextContainer, Exca
 import type { Scene } from "@excalidraw/element";
 import "./ConvertElementTypePopup.scss";
 import type App from "./App";
-export declare const convertElementTypePopupAtom: import("jotai/vanilla/atom").PrimitiveAtom<{
+export declare const convertElementTypePopupAtom: import("jotai").PrimitiveAtom<{
     type: "panel";
 } | null> & {
     init: {

package/dist/types/excalidraw/components/EyeDropper.d.ts

@@ -13,7 +13,7 @@ export type EyeDropperProperties = {
      **/
     colorPickerType: ColorPickerType;
 };
-export declare const activeEyeDropperAtom: import("jotai/vanilla/atom").PrimitiveAtom<EyeDropperProperties | null> & {
+export declare const activeEyeDropperAtom: import("jotai").PrimitiveAtom<EyeDropperProperties | null> & {
     init: EyeDropperProperties | null;
 };
 export declare const EyeDropper: React.FC<{

package/dist/types/excalidraw/components/OverwriteConfirm/OverwriteConfirmState.d.ts

@@ -11,7 +11,7 @@ export type OverwriteConfirmState = {
 } | {
     active: false;
 };
-export declare const overwriteConfirmStateAtom: import("jotai/vanilla/atom").PrimitiveAtom<OverwriteConfirmState> & {
+export declare const overwriteConfirmStateAtom: import("jotai").PrimitiveAtom<OverwriteConfirmState> & {
     init: OverwriteConfirmState;
 };
 export declare function openConfirmModal({ title, description, actionLabel, color, }: {

package/dist/types/excalidraw/components/SearchMenu.d.ts

@@ -1,5 +1,5 @@
 import "./SearchMenu.scss";
-export declare const searchItemInFocusAtom: import("jotai/vanilla/atom").PrimitiveAtom<number | null> & {
+export declare const searchItemInFocusAtom: import("jotai").PrimitiveAtom<number | null> & {
     init: number | null;
 };
 export declare const SearchMenu: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/excalidraw/components/Sidebar/Sidebar.d.ts

@@ -8,7 +8,7 @@ import "./Sidebar.scss";
  *
  * Since we can only render one Sidebar at a time, we can use a simple flag.
  */
-export declare const isSidebarDockedAtom: import("jotai/vanilla/atom").PrimitiveAtom<boolean> & {
+export declare const isSidebarDockedAtom: import("jotai").PrimitiveAtom<boolean> & {
     init: boolean;
 };
 export declare const SidebarInner: React.ForwardRefExoticComponent<Omit<{

package/dist/types/excalidraw/components/canvases/StaticCanvas.d.ts

@@ -1,9 +1,10 @@
 import React from "react";
 import type { NonDeletedExcalidrawElement, NonDeletedSceneElementsMap } from "@excalidraw/element/types";
 import type { RenderableElementsMap, StaticCanvasRenderConfig } from "../../scene/types";
-import type { StaticCanvasAppState } from "../../types";
+import type { AppClassProperties, StaticCanvasAppState } from "../../types";
 import type { RoughCanvas } from "roughjs/bin/canvas";
 type StaticCanvasProps = {
+    app: AppClassProperties;
     canvas: HTMLCanvasElement;
     rc: RoughCanvas;
     elementsMap: RenderableElementsMap;

package/dist/types/excalidraw/components/icons.d.ts

@@ -113,6 +113,8 @@ export declare const StrokeStyleDottedIcon: import("react/jsx-runtime").JSX.Elem
 export declare const SloppinessArchitectIcon: import("react/jsx-runtime").JSX.Element;
 export declare const SloppinessArtistIcon: import("react/jsx-runtime").JSX.Element;
 export declare const SloppinessCartoonistIcon: import("react/jsx-runtime").JSX.Element;
+export declare const strokeVariabilityConstantIcon: import("react/jsx-runtime").JSX.Element;
+export declare const strokeVariabilityVariableIcon: import("react/jsx-runtime").JSX.Element;
 export declare const EdgeSharpIcon: import("react/jsx-runtime").JSX.Element;
 export declare const EdgeRoundIcon: import("react/jsx-runtime").JSX.Element;
 export declare const ArrowheadNoneIcon: React.MemoExoticComponent<({ flip }: {

package/dist/types/excalidraw/data/blob.d.ts

@@ -90,9 +90,10 @@ fileHandle?: FileSystemFileHandle | null) => Promise<{
         currentItemStrokeColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
-        currentItemStrokeWidth: number;
+        currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
         currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
         currentItemRoughness: number;
+        currentItemStrokeVariability: import("@excalidraw/element/types").StrokeVariability;
         currentItemOpacity: number;
         currentItemFontFamily: import("@excalidraw/element/types").FontFamilyValues;
         currentItemFontSize: number;

package/dist/types/excalidraw/data/json.d.ts

@@ -91,9 +91,10 @@ export declare const loadFromJSON: (localAppState: AppState, localElements: read
         currentItemStrokeColor: string;
         currentItemBackgroundColor: string;
         currentItemFillStyle: ExcalidrawElement["fillStyle"];
-        currentItemStrokeWidth: number;
+        currentItemStrokeWidthKey: import("@excalidraw/common").StrokeWidthKey;
         currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
         currentItemRoughness: number;
+        currentItemStrokeVariability: import("@excalidraw/element/types").StrokeVariability;
         currentItemOpacity: number;
         currentItemFontFamily: import("@excalidraw/element/types").FontFamilyValues;
         currentItemFontSize: number;

package/dist/types/excalidraw/renderer/animation.d.ts

@@ -12,4 +12,5 @@ export declare class AnimationController {
     private static tick;
     static running(key: string): boolean;
     static cancel(key: string): void;
+    static reset(): void;
 }

package/dist/types/excalidraw/scene/Renderer.d.ts

@@ -272,6 +272,7 @@ export declare class Renderer {
             type: "image";
             fileId: import("@excalidraw/element/types").FileId | null;
             fileName: string | null;
+            thumbHash: string | null;
             status: "pending" | "saved" | "error";
             scale: [number, number];
             crop: import("@excalidraw/element/types").ImageCrop | null;
@@ -427,6 +428,7 @@ export declare class Renderer {
             points: readonly import("@excalidraw/math").LocalPoint[];
             pressures: readonly number[];
             simulatePressure: boolean;
+            strokeOptions: import("@excalidraw/element/types").StrokeOptions;
         }> & {
             isDeleted: boolean;
         }) | null;

package/dist/types/excalidraw/scene/index.d.ts

@@ -1,4 +1,4 @@
 export { isSomeElementSelected, getElementsWithinSelection, getSelectedElements, getTargetElements, } from "@excalidraw/element";
 export { calculateScrollCenter } from "./scroll";
-export { hasBackground, hasStrokeWidth, hasStrokeStyle, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
+export { hasBackground, hasStrokeWidth, hasStrokeStyle, hasFreedrawMode, canHaveArrowheads, canChangeRoundness, } from "@excalidraw/element";
 export { getNormalizedZoom, getNormalizedGridSize, getNormalizedGridStep, } from "./normalize";

package/dist/types/excalidraw/scene/types.d.ts

@@ -8,6 +8,7 @@ export type RenderableElementsMap = NonDeletedElementsMap & MakeBrand<"Renderabl
 export type StaticCanvasRenderConfig = {
     canvasBackgroundColor: AppState["viewBackgroundColor"];
     imageCache: AppClassProperties["imageCache"];
+    imageTransitionDuration?: number;
     renderGrid: boolean;
     /** when exporting the behavior is slightly different (e.g. we can't use
      CSS filters), and we disable render optimizations for best output */

package/dist/types/excalidraw/scroll.d.ts

@@ -0,0 +1,46 @@
+import type { ExcalidrawElement } from "@excalidraw/element/types";
+import type { AppState, Offsets } from "./types";
+export declare const SCROLL_TO_CONTENT_ANIMATION_KEY = "animateScrollToContent";
+export type ScrollToContentOptions = ({
+    fitToContent?: boolean;
+    fitToViewport?: never;
+    viewportZoomFactor?: number;
+    animate?: boolean;
+    duration?: number;
+} | {
+    fitToContent?: never;
+    fitToViewport?: boolean;
+    /** when fitToViewport=true, how much screen should the content cover,
+     * between 0.1 (10%) and 1 (100%) */
+    viewportZoomFactor?: number;
+    animate?: boolean;
+    duration?: number;
+}) & {
+    minZoom?: number;
+    maxZoom?: number;
+    canvasOffsets?: Offsets;
+};
+type Viewport = Pick<AppState, "scrollX" | "scrollY" | "zoom">;
+/**
+ * Scrolls (and optionally zooms) the viewport so that the given target is in
+ * view, optionally animating the transition.
+ */
+export declare const scrollToElements: (state: AppState, target: readonly ExcalidrawElement[], onFrame: (state: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "shouldCacheIgnoreZoom">) => void, opts?: ScrollToContentOptions) => void;
+/**
+ * Interpolates the viewport from `from` to `target` at the (already-eased)
+ * blend amount `factor` (0 = `from`, 1 = `target`).
+ *
+ * Zoom is interpolated geometrically (so it feels uniform), and rather than
+ * tweening scrollX/scrollY directly we tween the *focal point* — the scene
+ * point under the viewport center — and derive scroll from it. Mixing a linear
+ * scroll with a geometric zoom makes the focal point swoop sideways
+ * mid-animation (most visible when zooming out); gliding the focal point keeps
+ * it steady. `width/2/zoom - scroll` is the inverse of `centerScrollOn` without
+ * offsets, so factor 0/1 land exactly on `from`/`target`.
+ */
+export declare const interpolateViewport: ({ from, target, factor, }: {
+    from: Pick<AppState, "scrollX" | "scrollY" | "zoom" | "width" | "height">;
+    target: Viewport;
+    factor: number;
+}) => Viewport;
+export {};

package/dist/types/excalidraw/types.d.ts

@@ -1,7 +1,7 @@
-import type { IMAGE_MIME_TYPES, UserIdleState, throttleRAF, MIME_TYPES, ColorTuple, EditorInterface } from "@excalidraw/common";
+import type { IMAGE_MIME_TYPES, UserIdleState, throttleRAF, MIME_TYPES, ColorTuple, EditorInterface, StrokeWidthKey } from "@excalidraw/common";
 import type { LinearElementEditor } from "@excalidraw/element";
 import type { MaybeTransformHandleType } from "@excalidraw/element";
-import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, FontFamilyValues, FileId, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement, ArrangeAlgorithms, BindMode, ExcalidrawTextElement } from "@excalidraw/element/types";
+import type { PointerType, ExcalidrawLinearElement, NonDeletedExcalidrawElement, NonDeleted, TextAlign, ExcalidrawElement, GroupId, ExcalidrawBindableElement, Arrowhead, FontFamilyValues, FileId, Theme, StrokeRoundness, ExcalidrawEmbeddableElement, ExcalidrawMagicFrameElement, ExcalidrawFrameLikeElement, ExcalidrawElementType, ExcalidrawIframeLikeElement, OrderedExcalidrawElement, ExcalidrawNonSelectionElement, ArrangeAlgorithms, BindMode, ExcalidrawTextElement, StrokeVariability } from "@excalidraw/element/types";
 import type { Merge, MaybePromise, ValueOf, MakeBrand } from "@excalidraw/common/utility-types";
 import type { CaptureUpdateActionType, DurableIncrement, EphemeralIncrement } from "@excalidraw/element";
 import type { GlobalPoint } from "@excalidraw/math";
@@ -64,6 +64,8 @@ export type BinaryFileData = {
     id: FileId;
     fileName: string;
     dataURL: DataURL;
+    /** compact image placeholder, also stored on the corresponding image element */
+    thumbHash?: string;
     /**
      * Epoch timestamp in milliseconds
      */
@@ -294,9 +296,10 @@ export interface AppState {
     currentItemStrokeColor: string;
     currentItemBackgroundColor: string;
     currentItemFillStyle: ExcalidrawElement["fillStyle"];
-    currentItemStrokeWidth: number;
+    currentItemStrokeWidthKey: StrokeWidthKey;
     currentItemStrokeStyle: ExcalidrawElement["strokeStyle"];
     currentItemRoughness: number;
+    currentItemStrokeVariability: StrokeVariability;
     currentItemOpacity: number;
     currentItemFontFamily: FontFamilyValues;
     currentItemFontSize: number;
@@ -590,6 +593,8 @@ export type ExportOpts = {
 export type ImageOptions = Partial<{
     maxWidthOrHeight: number;
     maxFileSizeBytes: number;
+    /** duration of the placeholder-to-full-image crossfade in milliseconds */
+    placeholderTransitionDuration: number;
 }>;
 export type CanvasActions = Partial<{
     changeViewBackgroundColor: boolean;
@@ -645,7 +650,13 @@ export type AppClassProperties = {
     imageCache: Map<FileId, {
         image: HTMLImageElement | Promise<HTMLImageElement>;
         mimeType: ValueOf<typeof IMAGE_MIME_TYPES>;
+        isPlaceholder?: boolean;
+        placeholderImage?: HTMLImageElement;
+        transitionStart?: number;
     }>;
+    imageLoadingProgress: App["imageLoadingProgress"];
+    imageLoadingProgressEmitter: App["imageLoadingProgressEmitter"];
+    imagePlaceholderUpdateEmitter: App["imagePlaceholderUpdateEmitter"];
     files: BinaryFiles;
     editorInterface: App["editorInterface"];
     scene: App["scene"];
@@ -774,6 +785,8 @@ export interface ExcalidrawImperativeAPI {
     refresh: InstanceType<typeof App>["refresh"];
     setToast: InstanceType<typeof App>["setToast"];
     addFiles: (data: BinaryFileData[]) => void;
+    addImagePlaceholder: (fileId: FileId, file: File) => Promise<void>;
+    setImageLoadingProgress: (fileId: FileId, progress: number | null) => void;
     addImageElementsToScene: (imageFiles: {
         file: File;
         customData: Record<string, any>;

package/dist/types/laser-pointer/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./state";
+export type { Point } from "./math";

package/dist/types/laser-pointer/src/math.d.ts

@@ -0,0 +1,16 @@
+export type Point = [x: number, y: number, r: number];
+export declare function add([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function sub([ax, ay, ar]: Point, [bx, by, br]: Point): Point;
+export declare function smul([x, y, r]: Point, s: number): Point;
+export declare function norm([x, y, r]: Point): Point;
+export declare function rot([x, y, r]: Point, rad: number): Point;
+export declare function plerp(a: Point, b: Point, t: number): Point;
+export declare function lerp(a: number, b: number, t: number): number;
+export declare function angle(p: Point, p1: Point, p2: Point): number;
+export declare function normAngle(a: number): number;
+export declare function mag([x, y]: Point): number;
+export declare function dist([ax, ay]: Point, [bx, by]: Point): number;
+export declare function getCircleAndPerpendicularLineIntersectionsAtPoint(point: Point, direction: Point, radius: number): [Point, Point];
+export declare function runLength(ps: Point[]): number;
+export declare const clamp: (v: number, min: number, max: number) => number;
+export declare function distancePointToSegment(p3: Point, p1: Point, p2: Point): number;

package/dist/types/laser-pointer/src/simplify.d.ts

@@ -0,0 +1,2 @@
+import { type Point } from "./math";
+export declare function douglasPeucker(points: Point[], epsilon: number): Point[];

package/dist/types/laser-pointer/src/state.d.ts

@@ -0,0 +1,35 @@
+import type { Point } from "./math";
+export type SizeMappingDetails = {
+    pressure: number;
+    runningLength: number;
+    currentIndex: number;
+    totalLength: number;
+};
+export type LaserPointerOptions = {
+    size: number;
+    streamline: number;
+    simplify: number;
+    simplifyPhase: "tail" | "output" | "input";
+    keepHead: boolean;
+    sizeMapping: (details: SizeMappingDetails) => number;
+};
+export declare class LaserPointer {
+    static defaults: LaserPointerOptions;
+    static constants: {
+        cornerDetectionMaxAngle: number;
+        cornerDetectionVariance: (s: number) => 1 | 0.5;
+        maxTailLength: number;
+    };
+    options: LaserPointerOptions;
+    constructor(options: Partial<LaserPointerOptions>);
+    originalPoints: Point[];
+    private stablePoints;
+    private tailPoints;
+    private isFresh;
+    private get lastPoint();
+    addPoint(point: Point): void;
+    close(): void;
+    stabilizeTail(): void;
+    private getSize;
+    getStrokeOutline(sizeOverride?: number | undefined): Point[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myoc/common",
-  "version": "0.19.519",
+  "version": "0.19.520",
   "type": "module",
   "types": "./dist/types/common/src/index.d.ts",
   "main": "./dist/prod/index.js",