peachsim 0.1.1641 → 0.1.1653

package/dist-types/packages/peach-engine/src/engine/scroll.d.ts

@@ -0,0 +1,320 @@
+import { type AndroidEdgeEffectState } from './android-stretch-effect.d.ts';
+import { SootSimNode } from './node.d.ts';
+import { type TimedScrollControl, type TimedScrollPresentation, type ScrollRelease } from './scroll-momentum-math.d.ts';
+import { type ScrollContentInset } from './scroll-range.d.ts';
+import { type ScrollVelocitySample } from './scroll-velocity.d.ts';
+export declare function readContentInset(node: SootSimNode): {
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+};
+export declare function readAdjustedContentInset(node: SootSimNode): ScrollContentInset;
+export type ScrollNativeEvent = {
+    contentInset: ScrollContentInset;
+    contentOffset: {
+        x: number;
+        y: number;
+    };
+    contentSize: {
+        width: number;
+        height: number;
+    };
+    layoutMeasurement: {
+        width: number;
+        height: number;
+    };
+    zoomScale: number;
+    velocity?: {
+        x: number;
+        y: number;
+    };
+    targetContentOffset?: {
+        x: number;
+        y: number;
+    };
+};
+export declare function isScrollAxisFlipped(node: SootSimNode, horizontal: boolean): boolean;
+export declare function clipsContent(node: SootSimNode, style: {
+    overflow?: string;
+}): boolean;
+export declare function degenerateScrollClip(node: SootSimNode): boolean;
+export declare function getContentExtent(node: SootSimNode): {
+    width: number;
+    height: number;
+};
+type MaintainVisibleContentPositionConfig = {
+    minIndexForVisible: number;
+    autoscrollToTopThreshold: number | null;
+};
+export declare function captureMaintainVisibleContentPositionBeforeMutation(changedNode: SootSimNode | null | undefined): void;
+export declare function holdLayoutPassScrollEvents(): void;
+export declare function releaseLayoutPassScrollEvents(): void;
+export declare function takeLayoutPassScrollEvents(queuedLayoutEvents: boolean): (() => void) | null;
+export declare function sendScrollEvent(dispatch: () => void): void;
+export declare function syncScrollRuntimeContentMetrics(node: SootSimNode): boolean;
+export declare function findScrollViewAncestor(node: SootSimNode): SootSimNode | null;
+export interface ScrollDebugState {
+    nodeId: number;
+    testID: string | null;
+    horizontal: boolean;
+    offset: number;
+    offsetX: number;
+    offsetY: number;
+    virtualOffset: number | null;
+    dimension: number;
+    viewportWidth: number;
+    viewportHeight: number;
+    contentWidth: number;
+    contentHeight: number;
+    minOffset: number;
+    minOffsetX: number;
+    minOffsetY: number;
+    maxOffset: number;
+    maxOffsetX: number;
+    maxOffsetY: number;
+    contentInset: {
+        top: number;
+        bottom: number;
+        left: number;
+        right: number;
+    };
+    contentOffsetProp: {
+        x?: number;
+        y?: number;
+    } | null;
+    active: boolean;
+    isDrag: boolean;
+    startX: number | null;
+    startY: number | null;
+    lastX: number | null;
+    lastY: number | null;
+    lastTime: number | null;
+    sampleCount: number;
+    samples: Array<{
+        delta: number;
+        dt: number;
+    }>;
+    animating: boolean;
+    velocity: number;
+    bouncing: boolean | null;
+    bounces: boolean;
+    scrollToTargetValue: number | null;
+    zoomScale: number;
+    zooming: boolean | null;
+    minZoomScale: number;
+    maxZoomScale: number;
+    pagingEnabled: boolean;
+    refreshHolding: boolean | null;
+    refreshPullProgress: number | null;
+    androidEdgeEffect: AndroidEdgeEffectState | null;
+    maintainVisibleContentPosition: MaintainVisibleContentPositionConfig | null;
+    maintainVisibleContentPositionAnchor: {
+        childId: number;
+        testID: string | null;
+        frame: {
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+        };
+        fromMutation: boolean;
+    } | null;
+}
+export interface ScrollToOffsetOptions {
+    x?: number;
+    y?: number;
+    animated?: boolean;
+    fireScroll?: boolean;
+    forceScrollEvent?: boolean;
+    preserveEndAnchor?: boolean;
+    toEnd?: boolean;
+    statusBarScrollToTop?: boolean;
+}
+export interface ScrollZoomToRectOptions {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    animated?: boolean;
+}
+type WorkletScrollEventName = 'onScroll' | 'onScrollBeginDrag' | 'onScrollEndDrag' | 'onMomentumScrollBegin' | 'onMomentumScrollEnd';
+export declare class ScrollHandler {
+    node: SootSimNode;
+    horizontal: boolean;
+    active: boolean;
+    isDrag: boolean;
+    startX: number;
+    startY: number;
+    slopStartX: number;
+    slopStartY: number;
+    lastX: number;
+    lastY: number;
+    lastTime: number;
+    samples: ScrollVelocitySample[];
+    private crossPan;
+    allowsOverscroll: boolean;
+    rubberBandCoefficient: number;
+    private virtualOffset;
+    private axisFlipped;
+    private directionalLock;
+    private _androidPullAccum;
+    private lastRenderedOffset;
+    private lastRenderedZoomScale;
+    animating: boolean;
+    velocity: number;
+    private releasePanVelocity;
+    private readonly fastScroll;
+    private fastScrollMultiplier;
+    private dragStartOffset;
+    private rafId;
+    private pendingPinchRenderRafId;
+    private lastTickTime;
+    bouncing: boolean;
+    private momentumState;
+    private scrollToTargetValue;
+    private pendingInitialContentOffset;
+    private pendingInitialRangeClamp;
+    private statusBarScrollToTopActive;
+    zoomScale: number;
+    private zooming;
+    private uikitZoomActive;
+    private lastUIKitZoomRequest;
+    private pinchStartScale;
+    private pinchStartDistance;
+    private pinchFocalX;
+    private pinchFocalY;
+    private pinchAnchorX;
+    private pinchAnchorY;
+    private pinchStartOffsetX;
+    private pinchStartOffsetY;
+    pagingEnabled: boolean;
+    private pageSize;
+    private pageDragStartPage;
+    private _refreshHolding;
+    private _refreshHeldByShell;
+    private _refreshPullDistance;
+    private _lastRefreshingProp;
+    onRender: () => void;
+    onPresentationCommit: (() => void) | null;
+    onScrollBeginDrag: (() => void) | null;
+    private workletMomentumActive;
+    private programmaticScrollEnds;
+    private timedScroll;
+    onTimedScrollDrive: ((control: TimedScrollControl) => void) | null;
+    get compositorTimedScrollId(): number | null;
+    get isIndicatorlessScrollAnimation(): boolean;
+    get isProgrammaticScrollAnimating(): boolean;
+    applyTimedScrollPresentation(presentation: TimedScrollPresentation, x: number, y: number): boolean;
+    private lastScrollFireAt;
+    private createNativeScrollEvent;
+    private dispatchWorkletScrollEvent;
+    dispatchScrollPhaseToWorklets(eventName: Exclude<WorkletScrollEventName, 'onScroll'>, release?: ScrollRelease): void;
+    private fireOnScroll;
+    constructor(node: SootSimNode, horizontal: boolean, onRender: () => void);
+    get minZoomScale(): number;
+    get maxZoomScale(): number;
+    get zoomEnabled(): boolean;
+    get isRefreshing(): boolean;
+    get refreshPullProgress(): number;
+    private get refreshTriggerThreshold();
+    private get refreshHoldOffset();
+    get hasRefreshControl(): boolean;
+    private shouldTrackAndroidRefreshPull;
+    private shouldTrackRefreshPull;
+    private get offset();
+    private set offset(value);
+    private get dimension();
+    private get contentInset();
+    private get minOffsetX();
+    private get minOffsetY();
+    private get minOffset();
+    private get maxOffset();
+    private get crossOffset();
+    private set crossOffset(value);
+    private get crossMinOffset();
+    private get crossMaxOffset();
+    private get crossDimension();
+    private get contentZoomScale();
+    private get maxOffsetX();
+    private get maxOffsetY();
+    private get naturalMaxOffsetX();
+    private get naturalMaxOffsetY();
+    private requestedOffsetIsContentEnd;
+    private get zoomPanEnabled();
+    private captureMaintainVisibleContentPositionAnchor;
+    private applyMaintainVisibleContentPosition;
+    private virtualOffsetFromDisplayedOffset;
+    private syncVirtualOffsetFromDisplayed;
+    syncExternalOffset(opts?: {
+        fireScroll?: boolean;
+        forceScrollEvent?: boolean;
+    }): void;
+    syncExternalAndroidPullState(refreshPullProgress: number, androidEdgeEffect: AndroidEdgeEffectState | null): void;
+    syncContentMetrics(clampToRange?: boolean): boolean;
+    shiftForAutomaticTopInset(delta: number): void;
+    shiftScrollTo(next: {
+        x?: number;
+        y?: number;
+    }): boolean;
+    scrollToOffset(opts: ScrollToOffsetOptions): boolean;
+    private fireMomentumScrollEndProp;
+    private finishStatusBarScrollToTop;
+    syncRefreshProp(): void;
+    private syncRefreshToNode;
+    private clearAndroidEdgeEffect;
+    private updateAndroidEdgeEffect;
+    private beginAndroidEdgeRelease;
+    private tickAndroidEdgeRelease;
+    private absorbAndroidEdgeEffect;
+    touchDown(timestamp?: number): void;
+    begin(x: number, y: number, timestamp?: number, rubberBandCoefficient?: number): void;
+    move(x: number, y: number, timestamp?: number): boolean;
+    private displayDraggedOffset;
+    end(timestamp?: number): boolean;
+    triggerRefreshFromShellPull(): boolean;
+    cancel(): void;
+    private settleAfterTouch;
+    releaseFromTouch(): void;
+    scrollToTop(): void;
+    statusBarScrollToTop(): boolean;
+    beginPinch(focalX: number, focalY: number, initialDistance: number): void;
+    movePinch(_focalX: number, _focalY: number, currentDistance: number): void;
+    endPinch(): void;
+    private finishUIKitZoom;
+    doubleTapZoom(tapX: number, tapY: number): void;
+    zoomToRect(rect: ScrollZoomToRectOptions, animated?: boolean): boolean;
+    private getClampedZoomOffsets;
+    private applyZoomTo;
+    private animateZoomTo;
+    private syncZoomToNode;
+    private schedulePinchRender;
+    private cancelScheduledPinchRender;
+    private clampScrollOffsets;
+    private isScrollOutOfBounds;
+    private getPageSize;
+    private startAnimation;
+    private stopAnimation;
+    private finishWorkletMomentum;
+    private tickPhysics;
+    private momentumConfig;
+    release(): ScrollRelease;
+    private tickTimedScroll;
+    private tickSpring;
+    private createMomentumState;
+    private getMomentumState;
+    private applyMomentumStep;
+    getDebugState(): ScrollDebugState;
+}
+export declare function findFirstScrollView(node: SootSimNode): SootSimNode | null;
+export declare function findScrollViewInFirstDescendantChain(node: SootSimNode | null | undefined, opts?: {
+    skipHidden?: boolean;
+}): SootSimNode | null;
+export declare function findStatusBarScrollToTopView(root: SootSimNode, requestX: number): SootSimNode | null;
+export declare function scrollTabScreenContentToTop(screenNode: SootSimNode, onRender: () => void): boolean;
+export declare function isScrollNodeHoldingIndicator(node: SootSimNode): boolean;
+export declare function isScrollNodeProgrammaticallyAnimating(node: SootSimNode): boolean;
+export declare function getScrollDebugState(node: SootSimNode): ScrollDebugState;
+export declare function getScrollHandler(node: SootSimNode, initialOnRender: () => void): ScrollHandler;
+export declare function syncNodeRefreshProp(node: SootSimNode): void;
+export {};

package/dist-types/packages/peach-engine/src/engine/signal.d.ts

@@ -0,0 +1,7 @@
+export interface Signal<T> {
+    value: T;
+    peek(): T;
+    addListener(fn: () => void): () => void;
+}
+export declare function createSignal<T>(initial: T): Signal<T>;
+export declare function deriveSignal<T, U>(source: Signal<T>, project: (value: T) => U): Signal<U>;

package/dist-types/packages/peach-engine/src/engine/snapshot-cache-policy.d.ts

@@ -0,0 +1,6 @@
+export type AppSnapshotOwner = readonly [appId: string, epoch: number];
+export declare class AppSnapshotOwnership extends Map<string, number> {
+    adopt(owners: readonly AppSnapshotOwner[]): string[];
+    owns(appId: string, epoch: number | undefined): epoch is number;
+}
+export declare function isAppSnapshotOwners(value: unknown): value is AppSnapshotOwner[];

package/dist-types/packages/peach-engine/src/engine/svg-geometry.d.ts

@@ -0,0 +1,41 @@
+export interface SvgViewBoxTransform {
+    translateX: number;
+    translateY: number;
+    scaleX: number;
+    scaleY: number;
+}
+export declare function resolveSvgViewBoxTransform(viewportWidth: number, viewportHeight: number, viewBoxX: number, viewBoxY: number, viewBoxWidth: number, viewBoxHeight: number, preserveAspectRatio: unknown): SvgViewBoxTransform;
+export declare function resolveSvgRootViewBoxTransform(props: Record<string, unknown>, viewportWidth: number, viewportHeight: number): SvgViewBoxTransform & {
+    viewBoxWidth: number;
+    viewBoxHeight: number;
+};
+export interface SvgPathMetricPoint {
+    x: number;
+    y: number;
+}
+export interface SvgRenderableRect {
+    height: number;
+    width: number;
+    x: number;
+    y: number;
+}
+export interface SvgRenderableMatrix {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+}
+export declare function isSvgRenderablePointInStroke(target: unknown, point: SvgPathMetricPoint): boolean;
+export declare function createPathFillHitRegion(path: string): (x: number, y: number) => boolean;
+export declare function isSvgRenderablePointInFill(target: unknown, point: SvgPathMetricPoint): boolean;
+export declare function getSvgRenderableBBox(target: unknown, options: {
+    clipped: boolean;
+    fill: boolean;
+    markers: boolean;
+    stroke: boolean;
+}): SvgRenderableRect | null;
+export declare function getSvgRenderableCTM(target: unknown): SvgRenderableMatrix | null;
+export declare function getSvgRenderableTotalLength(target: unknown): number;
+export declare function getSvgRenderablePointAtLength(target: unknown, distance: number): SvgPathMetricPoint;

package/dist-types/packages/peach-engine/src/engine/text-attachment-paragraphs.d.ts

@@ -0,0 +1,10 @@
+import { SootSimNode } from './node.d.ts';
+export declare function startsWithGenericTextAttachment(node: SootSimNode): boolean;
+export declare class AttachmentLedParagraphs {
+    private natural;
+    private atStart;
+    text(text: string): boolean;
+    attachment(): boolean;
+    get inNaturalParagraph(): boolean;
+}
+export declare function hasMixedAttachmentParagraphs(node: SootSimNode): boolean;

package/dist-types/packages/peach-engine/src/engine/text-decoration.d.ts

@@ -0,0 +1,11 @@
+import type { TextParagraphInputs } from './canvaskit-renderer.d.ts';
+import type { SootSimNode } from './node.d.ts';
+import type { Paragraph } from './text-paragraph.d.ts';
+import type { SootSimStyle, RenderContext } from './types.d.ts';
+import type { Canvas } from 'canvaskit-wasm';
+export type TextPaintServices = Pick<typeof import('./canvaskit-renderer.d.ts'), 'acquirePaint' | 'releasePaint' | 'parseColor'> & {
+    strokesTextDecoration: (style: SootSimStyle['textDecorationStyle']) => boolean;
+    drawsSwiftUIDecoration: (style: SootSimStyle, run: SootSimStyle) => boolean;
+    drawsTextKitUnderline: (style: SootSimStyle, run: SootSimStyle) => boolean;
+};
+export declare function drawTextDecorations(node: SootSimNode, ctx: RenderContext, canvas: Canvas, inputs: TextParagraphInputs, para: Paragraph, decorationRuns: NonNullable<SootSimNode['_paragraphRuns']>, textPaintServices: TextPaintServices): void;

package/dist-types/packages/peach-engine/src/engine/text-line-break.d.ts

@@ -0,0 +1,22 @@
+import type { Paragraph } from './text-paragraph.d.ts';
+type Hyphenator = {
+    hyphenate(word: string): string[];
+};
+export interface TextHyphenation {
+    readonly locale: string;
+    readonly factor: number;
+}
+export declare function readTextHyphenation(style: {
+    _hyphenationLocale?: unknown;
+    _hyphenationFactor?: unknown;
+}): TextHyphenation | undefined;
+export declare function textHyphenationKey(hyphenation: TextHyphenation | undefined): string;
+export declare function installEnglishHyphenation(create: () => Hyphenator): void;
+export declare function hyphenateParagraph(text: string, para: Paragraph, width: number, hyphenation: TextHyphenation | undefined, pushOut: boolean, build: (text: string) => Paragraph): {
+    text: string;
+    para: Paragraph;
+    layoutWidth: number;
+};
+export declare function pushesOutLastWord(strategy: unknown): boolean;
+export declare function layoutParagraphLines(para: Paragraph, text: string, width: number, pushOut: boolean): number;
+export {};

package/dist-types/packages/peach-engine/src/engine/text-paint-receipt.d.ts

@@ -0,0 +1,98 @@
+import type { SootSimNode } from './node.d.ts';
+import type { Paragraph } from './text-paragraph.d.ts';
+import type { RenderContext } from './types.d.ts';
+export declare const TEXT_PAINT_RECEIPT: {
+    scope: string | null;
+};
+export type TextPaintPass = 'off-frame' | 'prewarm' | 'flat-bake' | 'recording' | 'walk';
+export declare function textPaintPass(ctx: Pick<RenderContext, 'prewarm' | 'flatBake' | 'recordingBoundary'>, offFrame: boolean): TextPaintPass;
+export interface TextPaintNativePreparation {
+    seq: number;
+    pass: TextPaintPass;
+    origin: {
+        x: number;
+        y: number;
+    };
+    args: number[];
+}
+export interface TextPaintReceiptRow {
+    nodeId: number;
+    seq: number;
+    paints: number;
+    path: 'native-leaf' | 'javascript';
+    pass: TextPaintPass;
+    lastNative: TextPaintNativePreparation | null;
+    text: string;
+    requestedFontFamily: string | null;
+    actualTypefaceIdentity: null;
+    fontSize: number;
+    fontGeneration: number;
+    dpr: number;
+    layout: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    absolute: {
+        x: number;
+        y: number;
+    };
+    origin: {
+        x: number;
+        y: number;
+    };
+    maxWidth: number;
+    contentHeight: number;
+    clips: boolean;
+    clipToHostBounds: boolean;
+    pad: {
+        left: number;
+        top: number;
+        right: number;
+        bottom: number;
+    };
+    textOffset: {
+        x: number;
+        y: number;
+    };
+    draw: Record<string, number>;
+    paragraph: {
+        height: number;
+        longestLine: number;
+        maxIntrinsicWidth: number;
+        lines: number;
+        alphabeticBaseline: number;
+    };
+    runs: {
+        size: number;
+        glyphs: number[];
+        advances: number[];
+    }[];
+}
+export declare function setTextPaintReceiptScope(scope: string | null): void;
+export declare function readTextPaintReceipt(): {
+    scope: string | null;
+    records: number;
+    dropped: number;
+    rows: TextPaintReceiptRow[];
+};
+export declare function recordTextPaint(node: SootSimNode, path: TextPaintReceiptRow['path'], pass: TextPaintPass, inputs: {
+    text: string;
+    style: {
+        fontFamily?: unknown;
+    };
+    fontSize: number;
+    clipToHostBounds: boolean;
+    pad: TextPaintReceiptRow['pad'];
+    textOffset: TextPaintReceiptRow['textOffset'];
+}, para: Paragraph, paint: {
+    x: number;
+    y: number;
+    maxWidth: number;
+    contentHeight: number;
+    clips: boolean;
+    dpr: number;
+    fontGeneration: number;
+    draw: Record<string, number>;
+}): void;

package/dist-types/packages/peach-engine/src/engine/text-paragraph.d.ts

@@ -0,0 +1,11 @@
+import type { AttributedParagraph } from './attributed-paragraph.d.ts';
+import type { SootSimNode } from './node.d.ts';
+import type { Canvas, Paragraph as NativeParagraph } from 'canvaskit-wasm';
+export type Paragraph = NativeParagraph | AttributedParagraph;
+type AttributedRuntime = typeof import('./attributed-paragraph.d.ts');
+export declare function hasAttributedParagraphStyle(node: SootSimNode): boolean;
+export declare function pendingAttributedParagraphForTree(root: SootSimNode): Promise<void> | null;
+export declare function getAttributedParagraphRuntime(): AttributedRuntime;
+export declare function isAttributedParagraph(paragraph: Paragraph | null | undefined): paragraph is AttributedParagraph;
+export declare function drawParagraph(canvas: Canvas, paragraph: Paragraph, x: number, y: number, scale?: number): void;
+export {};

package/dist-types/packages/peach-engine/src/engine/text-paragraphContract.d.ts

@@ -0,0 +1,34 @@
+import type { SootSimStyle } from './types.d.ts';
+type ParagraphColor = NonNullable<SootSimStyle['color']> | number;
+export interface AttributedParagraphStyle {
+    firstLineHeadIndent?: number;
+    headIndent?: number;
+    textAlign?: 'left' | 'right' | 'center' | 'justify' | 'start' | 'end';
+    minimumLineHeight?: number;
+    referenceLineHeight?: number;
+    marker?: {
+        kind: 'number';
+        text: string;
+        gap: number;
+        style: SootSimStyle;
+    } | {
+        kind: 'bullet';
+        size: number;
+        gap: number;
+        color: ParagraphColor;
+    } | {
+        kind: 'image';
+        source: string;
+        size: number;
+        gap: number;
+    };
+    quoteBorder?: {
+        width: number;
+        color: ParagraphColor;
+    };
+    background?: {
+        color: ParagraphColor;
+        borderRadius: number;
+    };
+}
+export {};

package/dist-types/packages/peach-engine/src/engine/text-transform.d.ts

@@ -0,0 +1 @@
+export declare function applyTextTransform(text: string, transform?: string): string;