@widgetic/embed-sdk 2.0.17 → 2.1.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +26 -4
- package/dist/browser/chunks/ABTestManager.js +1 -1
- package/dist/browser/chunks/api.js +1 -1
- package/dist/browser/chunks/core.js +1 -1
- package/dist/browser/chunks/renderers.js +1 -1
- package/dist/browser/chunks/scanner.js +1 -1
- package/dist/browser/chunks/workflows.js +1 -0
- package/dist/browser/embed-bootstrap.js +1 -1
- package/dist/browser/embed-sdk.js +1 -1
- package/dist/esm/chunks/ABTestManager.js +1 -1
- package/dist/esm/chunks/api.js +1 -1
- package/dist/esm/chunks/core.js +1 -1
- package/dist/esm/chunks/renderers.js +1 -1
- package/dist/esm/chunks/scanner.js +1 -1
- package/dist/esm/chunks/workflows.js +1 -0
- package/dist/esm/embed-bootstrap.js +1 -1
- package/dist/esm/embed-sdk.js +1 -1
- package/dist/esm/types/abTesting/abVisitor.d.ts +2 -0
- package/dist/esm/types/core/autoscale-manager.d.ts +6 -0
- package/dist/esm/types/embed-sdk.d.ts +1 -0
- package/dist/esm/types/sdk/embed-sdk.d.ts +1 -0
- package/dist/esm/types/utils/declarative-embed-parser.d.ts +5 -0
- package/dist/esm/types/utils/host-bridge-snapshot.d.ts +34 -1
- package/dist/esm/types/utils/host-workflow-watch.d.ts +62 -0
- package/dist/esm/types/utils/hydrate-published-host.d.ts +1 -0
- package/dist/esm/types/utils/mount-direct-widget.d.ts +19 -0
- package/dist/esm/types/utils/public-embed-lookup.d.ts +16 -0
- package/dist/esm/types/utils/published-host-bridge.d.ts +21 -3
- package/dist/esm/types/utils/workflow-code-loader.d.ts +14 -0
- package/dist/esm/types/utils/workflow-code-loader.umd.d.ts +32 -0
- package/dist/esm/types/utils/workflow-embed-registry.d.ts +15 -0
- package/dist/esm/types/utils/workflow-page-events.d.ts +41 -0
- package/dist/esm/types/utils/workflow-shared-contract.d.ts +35 -0
- package/dist/esm/types/utils/workflow-shared-services.d.ts +84 -0
- package/dist/esm/types/workflows/umd-entry.d.ts +1 -0
- package/dist/esm/types/workflows/visitor-position.d.ts +32 -0
- package/dist/esm/types/workflows/workflow-autoscale.d.ts +41 -0
- package/dist/esm/types/workflows/workflow-counts.d.ts +65 -0
- package/dist/esm/types/workflows/workflow-host.d.ts +71 -0
- package/dist/esm/types/workflows/workflow-lookup.d.ts +53 -0
- package/dist/esm/types/workflows/workflow-signals.d.ts +34 -0
- package/dist/esm/types/workflows/workflow-stage.d.ts +154 -0
- package/dist/umd/embed-bootstrap.js +1 -1
- package/dist/umd/embed-sdk-workflows.js +1 -0
- package/dist/umd/embed-sdk.js +1 -1
- package/package.json +2 -1
|
@@ -0,0 +1,71 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The runtime of one `<widgetic workflow-id composition-id>` tag: what turns a published workflow into a visitor moving
|
|
3
|
+
* from one composition to the next, in place, without the page reloading.
|
|
4
|
+
*
|
|
5
|
+
* How it goes, in the order it happens:
|
|
6
|
+
*
|
|
7
|
+
* 1. The composition the tag names is shown at once (the visitor's own, if they are coming back), so a workflow never
|
|
8
|
+
* makes a page wait. While that is loading, the workflow is read from the gateway (the live version, or the one a
|
|
9
|
+
* returning visitor started on).
|
|
10
|
+
* 2. When both are in, the workflow starts. A workflow that is paused, gone or does not contain the tag's composition
|
|
11
|
+
* leaves a plain embed of the tag's composition. A running one follows heights from now on, starts listening for what
|
|
12
|
+
* its triggers wait for, tells the widget what to report and starts the clocks of its Scheduled triggers.
|
|
13
|
+
* 3. Each thing that happens (a saved entry, an action in the widget, an event of the page, a wait that is over) goes to
|
|
14
|
+
* the engine, which says whether the visitor moves. If so, the next composition is built beside the one on screen
|
|
15
|
+
* and takes its place when it is ready. If it cannot be shown, the visitor stays where they are, the page and the
|
|
16
|
+
* counts are told, and one more try is made half a minute later.
|
|
17
|
+
*
|
|
18
|
+
* The engine decides, the viewport shows (workflow-stage.ts), and this file connects them to the visitor's browser: where
|
|
19
|
+
* the visitor is kept, what is counted, what the widgets are told, when the clocks go off. Everything it needs from outside
|
|
20
|
+
* is in `WorkflowHostServices`, so every step of the above can be walked through in a test without a gateway or a widget.
|
|
21
|
+
*
|
|
22
|
+
* A workflow is never a reason for a page to show nothing. Whatever goes wrong here ends as a plain embed of the tag's
|
|
23
|
+
* composition (see `startWorkflowEmbed`'s return value and `becomePlain`), and everything is logged once, at debug level.
|
|
24
|
+
*/
|
|
25
|
+
import { type WorkflowWatch } from "../utils/host-workflow-watch";
|
|
26
|
+
import { WorkflowCounts, type WorkflowCountsOptions } from "./workflow-counts";
|
|
27
|
+
import { type WorkflowLookup, type WorkflowLookupOptions } from "./workflow-lookup";
|
|
28
|
+
import { type ViewportServices } from "./workflow-stage";
|
|
29
|
+
/** How long after a failed step the visitor is moved on again, if they are still where they were. Once. */
|
|
30
|
+
export declare const RETRY_AFTER_FAILED_STEP_MILLISECONDS = 30000;
|
|
31
|
+
/** What the runtime needs of the counts. */
|
|
32
|
+
type CountsPort = Pick<WorkflowCounts, "start" | "count" | "flushBeforeLeaving" | "dispose">;
|
|
33
|
+
/** What a test may steer about the viewport. */
|
|
34
|
+
export interface ViewportTuning {
|
|
35
|
+
createHeightObserver?: ViewportServices["createHeightObserver"];
|
|
36
|
+
measureStageHeight?: ViewportServices["measureStageHeight"];
|
|
37
|
+
readyTimeoutMilliseconds?: number;
|
|
38
|
+
prefersReducedMotion?: () => boolean;
|
|
39
|
+
}
|
|
40
|
+
/** Everything the runtime reaches for outside itself. The defaults are the real ones. */
|
|
41
|
+
export interface WorkflowHostServices {
|
|
42
|
+
fetchWorkflow: (workflowId: string, options?: WorkflowLookupOptions) => Promise<WorkflowLookup>;
|
|
43
|
+
createCounts: (options: WorkflowCountsOptions) => CountsPort;
|
|
44
|
+
/** Tells the widget in a stage what to report: a widget in a frame by message, a widget in the page by property. */
|
|
45
|
+
deliverWatch: (stage: HTMLElement, compositionId: string, watch: WorkflowWatch) => void;
|
|
46
|
+
/** Gets a composition ready (its lookup, its module) so that showing it takes no time. */
|
|
47
|
+
prefetchComposition: (compositionId: string) => void;
|
|
48
|
+
/** Runs `task` when the page has nothing better to do. Returns what takes it back. */
|
|
49
|
+
whenIdle: (task: () => void) => () => void;
|
|
50
|
+
viewport: ViewportTuning;
|
|
51
|
+
}
|
|
52
|
+
export interface StartWorkflowEmbedOptions {
|
|
53
|
+
/** Gives a stage its widget: the SDK's own hydration of a `<widgetic composition-id>` tag. */
|
|
54
|
+
hydrate: (stage: HTMLElement) => void;
|
|
55
|
+
/** Does for the tag what the SDK does when a plain embed is mounted. */
|
|
56
|
+
markMounted: (host: HTMLElement) => void;
|
|
57
|
+
/** A width every composition takes (an overlay that spans the screen). */
|
|
58
|
+
width?: string;
|
|
59
|
+
services?: Partial<WorkflowHostServices>;
|
|
60
|
+
}
|
|
61
|
+
export interface WorkflowEmbedController {
|
|
62
|
+
/** Ends the workflow: timers, listeners, counts and the compositions it built. Safe to call more than once. */
|
|
63
|
+
stop: () => void;
|
|
64
|
+
}
|
|
65
|
+
/**
|
|
66
|
+
* Runs the workflow of a `<widgetic workflow-id composition-id>` tag. Returns null, having done nothing to the page, when
|
|
67
|
+
* the tag cannot run one (the id cannot be a workflow's, no composition is named, or something fails right at the start):
|
|
68
|
+
* the caller then mounts the tag as a plain embed.
|
|
69
|
+
*/
|
|
70
|
+
export declare function startWorkflowEmbed(host: HTMLElement, options: StartWorkflowEmbedOptions): WorkflowEmbedController | null;
|
|
71
|
+
export {};
|
|
@@ -0,0 +1,53 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Reading a workflow from the gateway's public door.
|
|
3
|
+
*
|
|
4
|
+
* GET {api}/embed/workflows/{id} the live version (or "paused")
|
|
5
|
+
* GET {api}/embed/workflows/{id}/versions/{versionId} one published version, for a visitor who is finishing it
|
|
6
|
+
*
|
|
7
|
+
* The door is at the root of the API host (not under /v1), open to every website and read with a plain cross-origin
|
|
8
|
+
* GET: no cookies, no headers, nothing of the page is sent. The answer may be cached by the browser for a few seconds,
|
|
9
|
+
* which is how a publish or a pause reaches visitors within moments.
|
|
10
|
+
*
|
|
11
|
+
* Everything that is not a usable live or paused workflow ends as "unavailable", and the caller then behaves as a plain
|
|
12
|
+
* embed of its `composition-id`. A workflow can never be a reason for a page to show nothing.
|
|
13
|
+
*/
|
|
14
|
+
import { type WorkflowGraph } from "@widgetic/workflows-engine";
|
|
15
|
+
/** What a visitor's browser reads of a live workflow. */
|
|
16
|
+
export interface PublicWorkflow {
|
|
17
|
+
workflowId: string;
|
|
18
|
+
/** The published version this answer is for. A visitor who starts on it finishes on it. */
|
|
19
|
+
versionId: string;
|
|
20
|
+
versionNumber?: number;
|
|
21
|
+
publishedAt?: string;
|
|
22
|
+
/** The composition a new visitor starts on, so the page can show it while the graph is still being read. */
|
|
23
|
+
startCompositionId?: string;
|
|
24
|
+
/** The zone date and time triggers are read in. */
|
|
25
|
+
timezone: string;
|
|
26
|
+
/** In the runtime form: no positions, no editor notes. Checked by the engine's parser. */
|
|
27
|
+
graph: WorkflowGraph;
|
|
28
|
+
/** What lets the page report counts for this version (absent: the page reports nothing). */
|
|
29
|
+
eventToken?: string;
|
|
30
|
+
}
|
|
31
|
+
export type WorkflowLookup = {
|
|
32
|
+
status: "live";
|
|
33
|
+
workflow: PublicWorkflow;
|
|
34
|
+
origin: string;
|
|
35
|
+
} | {
|
|
36
|
+
status: "paused";
|
|
37
|
+
} | {
|
|
38
|
+
status: "unavailable";
|
|
39
|
+
reason: "not_found" | "unreachable" | "unreadable";
|
|
40
|
+
};
|
|
41
|
+
export interface WorkflowLookupOptions {
|
|
42
|
+
/** Read this version instead of the live one. */
|
|
43
|
+
versionId?: string;
|
|
44
|
+
/** The API hosts to ask, in order. By default the ones every public lookup asks. */
|
|
45
|
+
origins?: string[];
|
|
46
|
+
}
|
|
47
|
+
/** Could this be the id of a workflow? (A `workflow-id` that cannot be one is never put in an address.) */
|
|
48
|
+
export declare function isUsableWorkflowId(workflowId: string): boolean;
|
|
49
|
+
/**
|
|
50
|
+
* Reads the live workflow (or one version of it) from the first host that knows it. Always resolves: whatever goes
|
|
51
|
+
* wrong is an "unavailable" answer, and the embed behaves as a plain embed.
|
|
52
|
+
*/
|
|
53
|
+
export declare function fetchPublicWorkflow(workflowId: string, options?: WorkflowLookupOptions): Promise<WorkflowLookup>;
|
|
@@ -0,0 +1,34 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* What a visitor does in the composition on screen, turned into the signals the engine decides on.
|
|
3
|
+
*
|
|
4
|
+
* A stage tells the workflow two kinds of thing:
|
|
5
|
+
*
|
|
6
|
+
* - an entry was saved (Input added): the widget reports `widgetic:submitted` with the table, the entry and the
|
|
7
|
+
* values of the columns a published condition reads. A widget in a frame reports it through the host bridge; a
|
|
8
|
+
* widget mounted in the page dispatches the same event on its mount target. Either way it reaches the stage.
|
|
9
|
+
* - an action a trigger waits for (Action in the widget): a widget in a frame reports `widgetic:goal` with the id of
|
|
10
|
+
* the action; for a widget mounted in the page the SDK sees the click, the submit and the play itself, inside the
|
|
11
|
+
* shadow root, as it does for an A/B test.
|
|
12
|
+
*
|
|
13
|
+
* Only what the watch names is passed on: a table nobody waits for, a column nobody reads and an action nobody waits
|
|
14
|
+
* for are dropped here, so they never reach the engine, the counts or the page.
|
|
15
|
+
*/
|
|
16
|
+
import type { FieldValue, Signal, WatchList } from "@widgetic/workflows-engine";
|
|
17
|
+
type EntryValue = Exclude<FieldValue, null>;
|
|
18
|
+
/** The values of an entry that a published condition reads: text of up to 200 characters, finite numbers, yes/no. */
|
|
19
|
+
export declare function sanitizeEntryValues(rawValues: unknown, allowedColumns: ReadonlySet<string>): Record<string, EntryValue>;
|
|
20
|
+
export interface StageSignalsOptions {
|
|
21
|
+
/** The stage element the composition is shown in. */
|
|
22
|
+
stage: HTMLElement;
|
|
23
|
+
/** What the composition on this stage needs reported. */
|
|
24
|
+
watch: WatchList;
|
|
25
|
+
/** Handed the signals one thing a visitor did makes, in the order of the watch (the first that moves the visitor wins). */
|
|
26
|
+
emit: (signals: Signal[]) => void;
|
|
27
|
+
}
|
|
28
|
+
export interface StageSignals {
|
|
29
|
+
/** Stops listening. Nothing is reported afterwards. */
|
|
30
|
+
stop: () => void;
|
|
31
|
+
}
|
|
32
|
+
/** Starts listening for what a visitor does on a stage. */
|
|
33
|
+
export declare function attachStageSignals({ stage, watch, emit, }: StageSignalsOptions): StageSignals;
|
|
34
|
+
export {};
|
|
@@ -0,0 +1,154 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The place a workflow shows its compositions in.
|
|
3
|
+
*
|
|
4
|
+
* A `<widgetic workflow-id>` tag gets one viewport, which holds one stage for the composition on screen. A stage is an
|
|
5
|
+
* ordinary `<widgetic composition-id>` element that the SDK hydrates like any other, so lookups, refusals, errors and
|
|
6
|
+
* the events a widget reports all work the way they do for a plain embed, and every event bubbles up to the tag.
|
|
7
|
+
*
|
|
8
|
+
* To move on to the next composition the viewport builds it beside the one on screen, out of sight. The one on screen
|
|
9
|
+
* is never touched until the next is ready, so a visitor never sees a blank, and the page never reloads. Then the new
|
|
10
|
+
* stage takes the place of the old one and the viewport follows the new height, animated.
|
|
11
|
+
*
|
|
12
|
+
* Until the workflow is known to exist the viewport is plain: it looks, to the page, exactly as the embed would without
|
|
13
|
+
* it. Only when it is told to follow heights does it clip to the height of what is shown (`enableAutoscale`), and it
|
|
14
|
+
* lets go again if the workflow turns out to be paused or gone (`releaseAutoscale`).
|
|
15
|
+
*
|
|
16
|
+
* What to show next, and when, is decided elsewhere (workflow-host.ts). This file only builds and swaps stages and
|
|
17
|
+
* keeps the height right. The decisions about heights are in workflow-autoscale.ts.
|
|
18
|
+
*/
|
|
19
|
+
/** Marks the viewport the SDK puts on a tag. */
|
|
20
|
+
export declare const VIEWPORT_ATTRIBUTE = "data-widgetic-workflow-viewport";
|
|
21
|
+
/** Marks a stage: a composition built for a workflow. */
|
|
22
|
+
export declare const STAGE_ATTRIBUTE = "data-widgetic-workflow-stage";
|
|
23
|
+
/** Tells the viewport a stage has this height now. */
|
|
24
|
+
export type HeightReport = (entries: Array<{
|
|
25
|
+
target: Element;
|
|
26
|
+
height: number;
|
|
27
|
+
}>) => void;
|
|
28
|
+
/** Whatever tells the viewport that the height of a stage changed (the browser's ResizeObserver). */
|
|
29
|
+
export interface HeightObserver {
|
|
30
|
+
observe(target: Element): void;
|
|
31
|
+
unobserve(target: Element): void;
|
|
32
|
+
disconnect(): void;
|
|
33
|
+
}
|
|
34
|
+
export interface StageDescription {
|
|
35
|
+
compositionId: string;
|
|
36
|
+
/** The first stage the viewport built. */
|
|
37
|
+
isFirst: boolean;
|
|
38
|
+
/** Whether it shows the composition the tag names, and so gets what the page wrote in the tag for it. */
|
|
39
|
+
carriesPageContent: boolean;
|
|
40
|
+
}
|
|
41
|
+
export interface ViewportServices {
|
|
42
|
+
/** Gives a stage its widget (in the SDK: the same hydration a plain tag gets). */
|
|
43
|
+
hydrate: (stage: HTMLElement) => void;
|
|
44
|
+
/** Starts watching heights. Returns null when the browser cannot (heights are then taken when a stage is ready). */
|
|
45
|
+
createHeightObserver?: (report: HeightReport) => HeightObserver | null;
|
|
46
|
+
/** The height a stage has now, in pixels. */
|
|
47
|
+
measureStageHeight?: (stage: HTMLElement) => number;
|
|
48
|
+
/** A stage was built and is about to be added to the page, before anything is loaded into it. */
|
|
49
|
+
onStageCreated?: (stage: HTMLElement, description: StageDescription) => void;
|
|
50
|
+
/** A stage was taken off the page (replaced, failed, or the viewport went). */
|
|
51
|
+
onStageRemoved?: (stage: HTMLElement) => void;
|
|
52
|
+
/** How long the next composition is given to appear. */
|
|
53
|
+
readyTimeoutMilliseconds?: number;
|
|
54
|
+
}
|
|
55
|
+
export interface WorkflowViewportOptions {
|
|
56
|
+
/** The `<widgetic workflow-id>` tag. */
|
|
57
|
+
host: HTMLElement;
|
|
58
|
+
services: ViewportServices;
|
|
59
|
+
/** Whether the visitor asked their device for less motion. By default read from the browser. */
|
|
60
|
+
prefersReducedMotion?: () => boolean;
|
|
61
|
+
/** A width every stage takes whatever the tag says (an overlay that spans the whole screen). */
|
|
62
|
+
widthOverride?: string;
|
|
63
|
+
}
|
|
64
|
+
export type StageReadiness = {
|
|
65
|
+
status: "ready";
|
|
66
|
+
} | {
|
|
67
|
+
status: "failed";
|
|
68
|
+
reason: "error" | "timeout" | "stopped";
|
|
69
|
+
code?: string;
|
|
70
|
+
};
|
|
71
|
+
export type SwapOutcome = {
|
|
72
|
+
status: "shown";
|
|
73
|
+
stage: HTMLElement;
|
|
74
|
+
} | {
|
|
75
|
+
status: "failed";
|
|
76
|
+
reason: "error" | "timeout" | "busy" | "stopped";
|
|
77
|
+
code?: string;
|
|
78
|
+
};
|
|
79
|
+
export declare class WorkflowViewport {
|
|
80
|
+
private readonly host;
|
|
81
|
+
private readonly services;
|
|
82
|
+
private readonly prefersReducedMotion;
|
|
83
|
+
private readonly widthOverride;
|
|
84
|
+
private readonly viewportElement;
|
|
85
|
+
private current;
|
|
86
|
+
private incoming;
|
|
87
|
+
private heightObserver;
|
|
88
|
+
private attributeObserver;
|
|
89
|
+
private autoscaleOn;
|
|
90
|
+
private appliedHeight;
|
|
91
|
+
private debounceTimer;
|
|
92
|
+
private pendingHeight;
|
|
93
|
+
private destroyed;
|
|
94
|
+
private warnedAboutFrameWithoutHeight;
|
|
95
|
+
constructor(options: WorkflowViewportOptions);
|
|
96
|
+
/** The stage on screen, if any. */
|
|
97
|
+
currentStage(): HTMLElement | null;
|
|
98
|
+
/**
|
|
99
|
+
* Builds the first composition's stage and starts loading it. `ready` settles when it is shown or has failed (it is
|
|
100
|
+
* never given up on for being slow: a plain embed is not either).
|
|
101
|
+
*/
|
|
102
|
+
showFirstStage(compositionId: string): {
|
|
103
|
+
stage: HTMLElement;
|
|
104
|
+
ready: Promise<StageReadiness>;
|
|
105
|
+
};
|
|
106
|
+
/**
|
|
107
|
+
* From now on the viewport is as tall as what it shows, and follows when that changes. Until then it is plain. The
|
|
108
|
+
* height is taken as soon as the composition on screen is ready, without an animation.
|
|
109
|
+
*/
|
|
110
|
+
enableAutoscale(): void;
|
|
111
|
+
/** The workflow is not going to run (it is paused or gone): the viewport becomes what a plain embed looks like. */
|
|
112
|
+
releaseAutoscale(): void;
|
|
113
|
+
/**
|
|
114
|
+
* Builds the next composition beside the one on screen and, once it is ready, takes the place of it. If it fails or
|
|
115
|
+
* does not appear in time, the one on screen stays exactly as it was.
|
|
116
|
+
*/
|
|
117
|
+
swapTo(compositionId: string): Promise<SwapOutcome>;
|
|
118
|
+
/** Takes everything this viewport put on the page away. Safe to call more than once. */
|
|
119
|
+
destroy(): void;
|
|
120
|
+
private buildStage;
|
|
121
|
+
/** The overrides the page wrote on the tag, and the items and JSON blocks in it: the tag composition's alone. */
|
|
122
|
+
private copyWhatThePageWroteForTheTagComposition;
|
|
123
|
+
/** What the page changes on the tag while the workflow runs reaches the stages. */
|
|
124
|
+
private observeMirroredAttributes;
|
|
125
|
+
private mirrorAttributesToStages;
|
|
126
|
+
/**
|
|
127
|
+
* Settles when the stage's widget is up (it says so, or its frame has loaded) or has failed (it says so, or the time
|
|
128
|
+
* allowed ran out). A `null` time is no limit.
|
|
129
|
+
*/
|
|
130
|
+
private waitUntilShown;
|
|
131
|
+
private removeStage;
|
|
132
|
+
private noteFrameWithoutHeight;
|
|
133
|
+
/** Out of sight, in the place the stage will take: it loads and lays out but cannot be seen or used. */
|
|
134
|
+
private hideBeside;
|
|
135
|
+
private revealInPlace;
|
|
136
|
+
/** Stages lie on top of each other, so that the viewport's own height is what the page sees. */
|
|
137
|
+
private positionAsLayer;
|
|
138
|
+
private positionInFlow;
|
|
139
|
+
private measure;
|
|
140
|
+
/** Reserves what the composition took last time, so the page does not jump when the first one is shown. */
|
|
141
|
+
private holdRoomFor;
|
|
142
|
+
private settings;
|
|
143
|
+
/** The room an overlay has on the visitor's screen, or null for an embed that sits in the page. */
|
|
144
|
+
private overlayCap;
|
|
145
|
+
private onHeightsReported;
|
|
146
|
+
/**
|
|
147
|
+
* Gives the viewport the height of what is shown. A height that comes from a swap or from the first composition is
|
|
148
|
+
* taken at once; one that comes from the composition changing by itself waits until it has held still, and is only
|
|
149
|
+
* followed when it moved by more than the threshold.
|
|
150
|
+
*/
|
|
151
|
+
private applyHeight;
|
|
152
|
+
private setHeight;
|
|
153
|
+
private clearHeightTimer;
|
|
154
|
+
}
|