motion-start 0.0.1

package/src/render/utils/state.ts

@@ -0,0 +1,113 @@
+/** 
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+import type { AxisBox2D, BoxDelta, Point2D } from "../../types/geometry.js";
+/**
+ * Represents the size and position we want to project a given visual
+ * element into.
+ */
+export interface TargetProjection {
+    /**
+     * Whether we should attempt to project into this target box.
+     */
+    isEnabled: boolean;
+    /**
+     * Whether we should attempt to project into this target box.
+     */
+    isHydrated: boolean;
+    /**
+     * Whether this target box is locked. We might want to lock the box, for
+     * instance if the user is dragging or animating it. Otherwise
+     * we want to rebase the target box ontop of the measured layout.
+     */
+    isTargetLocked: boolean;
+    /**
+     * The parent-relative box we want to derive the viewport box from, if defined.
+     * This is currently all relative to the top/left of the parent box,
+     * but could be expanded in the future.
+     */
+    relativeTarget?: AxisBox2D;
+    /**
+     * The viewport-relative box we want to project the element into.
+     */
+    target: AxisBox2D;
+    /**
+     * The viewport-relative box we want to project the element into after
+     * it's had x/y/scale transforms applied.
+     */
+    targetFinal: AxisBox2D;
+}
+/**
+ * Data about the element's current layout. Contains the latest measurements
+ * as well as the latest calculations of how to project from this layout
+ * into a given TargetProjection.
+ */
+export interface LayoutState {
+    /**
+     * Whether we've hydrated this state with the latest measurements.
+     */
+    isHydrated: boolean;
+    /**
+     * The latest viewport-box measurements of the element without transforms.
+     */
+    layout: AxisBox2D;
+    /**
+     * The measured viewport box as corrected by parent transforms up the
+     * visual element tree.
+     */
+    layoutCorrected: AxisBox2D;
+    /**
+     * The cumulative tree scale for this element. This starts at 1 per axis.
+     * When a transform is applied to an element we also apply it to the tree scale.
+     * The final value is used for scale-correcting values like border-radius,
+     * as well as ensuring calculated CSS translations are applied to compensate
+     * for this scale.
+     */
+    treeScale: Point2D;
+    /**
+     * A mutable piece of data that we write into the latest projection calculations
+     * that, when applied to an element, will project it from its layoutCorrected
+     * box into the provided TargetProjection.target
+     */
+    delta: BoxDelta;
+    /**
+     * A mutable piece of data that will project an element from layoutCorrected
+     * into TargetProjection.targetFinal.
+     */
+    deltaFinal: BoxDelta;
+    /**
+     * The latest generated delta transform. This is used to compare against
+     * the previously-generated transform to determine whether we need to trigger
+     * a render.
+     */
+    deltaTransform: string;
+}
+
+
+/** 
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+import { axisBox, delta } from '../../utils/geometry/index.js';
+
+var createProjectionState = function () { return ({
+    isEnabled: false,
+    isTargetLocked: false,
+    target: axisBox(),
+    targetFinal: axisBox(),
+} as TargetProjection); };
+function createLayoutState() {
+    return {
+        isHydrated: false,
+        layout: axisBox(),
+        layoutCorrected: axisBox(),
+        treeScale: { x: 1, y: 1 },
+        delta: delta(),
+        deltaFinal: delta(),
+        deltaTransform: "",
+    } as LayoutState;
+}
+var zeroLayout = createLayoutState();
+
+export { createLayoutState, createProjectionState, zeroLayout };

package/src/render/utils/types.ts

@@ -0,0 +1,12 @@
+/** 
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+export enum AnimationType {
+    Animate = "animate",
+    Hover = "whileHover",
+    Tap = "whileTap",
+    Drag = "whileDrag",
+    Focus = "whileFocus",
+    Exit = "exit"
+}

package/src/render/utils/variants.ts

@@ -0,0 +1,76 @@
+/** 
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+import type { MotionProps } from "../../motion/types";
+import type { TargetAndTransition, TargetResolver } from "../../types";
+import type { ResolvedValues, VisualElement } from "../types";
+
+
+/** 
+based on framer-motion@4.0.3,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+ * Decides if the supplied variable is an array of variant labels
+ */
+function isVariantLabels(v: unknown): v is string[] {
+    return Array.isArray(v);
+}
+/**
+ * Decides if the supplied variable is variant label
+ */
+function isVariantLabel(v: unknown): v is string | string[] {
+    return typeof v === "string" || isVariantLabels(v);
+}
+/**
+ * Creates an object containing the latest state of every MotionValue on a VisualElement
+ */
+function getCurrent(visualElement) {
+    var current = {};
+    visualElement.forEachValue(function (value, key) { return (current[key] = value.get()); });
+    return current;
+}
+/**
+ * Creates an object containing the latest velocity of every MotionValue on a VisualElement
+ */
+function getVelocity(visualElement) {
+    var velocity = {};
+    visualElement.forEachValue(function (value, key) { return (velocity[key] = value.getVelocity()); });
+    return velocity;
+}
+function resolveVariantFromProps(props: MotionProps, definition: TargetAndTransition | TargetResolver, custom?: any, currentValues?: ResolvedValues, currentVelocity?: ResolvedValues): TargetAndTransition;
+function resolveVariantFromProps(props: MotionProps, definition?: string | TargetAndTransition | TargetResolver, custom?: any, currentValues?: ResolvedValues, currentVelocity?: ResolvedValues): undefined | TargetAndTransition;
+function resolveVariantFromProps(props: MotionProps, definition?: string | TargetAndTransition | TargetResolver, custom?: any, currentValues?: ResolvedValues, currentVelocity?: ResolvedValues) {
+    var _a;
+    if (currentValues === void 0) { currentValues = {}; }
+    if (currentVelocity === void 0) { currentVelocity = {}; }
+    if (typeof definition === "string") {
+        definition = (_a = props.variants) === null || _a === void 0 ? void 0 : _a[definition];
+    }
+    return typeof definition === "function"
+        ? definition(custom !== null && custom !== void 0 ? custom : props.custom, currentValues, currentVelocity)
+        : definition;
+}
+function resolveVariant(visualElement: VisualElement, definition: TargetAndTransition | TargetResolver, custom?: any): TargetAndTransition;
+function resolveVariant(visualElement: VisualElement, definition?: string | TargetAndTransition | TargetResolver, custom?: any): TargetAndTransition | undefined;
+function resolveVariant(visualElement: VisualElement, definition?: string | TargetAndTransition | TargetResolver, custom?: any) {
+    var props = visualElement.getProps();
+    return resolveVariantFromProps(props, definition, custom !== null && custom !== void 0 ? custom : props.custom, getCurrent(visualElement), getVelocity(visualElement));
+}
+function checkIfControllingVariants(props: MotionProps) {
+    var _a;
+    return (typeof ((_a = props.animate) === null || _a === void 0 ? void 0 : _a.start) === "function" ||
+        isVariantLabel(props.initial) ||
+        isVariantLabel(props.animate) ||
+        isVariantLabel(props.whileHover) ||
+        isVariantLabel(props.whileDrag) ||
+        isVariantLabel(props.whileTap) ||
+        isVariantLabel(props.whileFocus) ||
+        isVariantLabel(props.exit));
+}
+function checkIfVariantNode(props: MotionProps) {
+    return Boolean(checkIfControllingVariants(props) || props.variants);
+}
+
+export { checkIfControllingVariants, checkIfVariantNode, isVariantLabel, isVariantLabels, resolveVariant, resolveVariantFromProps };

package/src/types/geometry.ts

@@ -0,0 +1,91 @@
+/** 
+based on framer-motion@4.1.17,
+Copyright (c) 2018 Framer B.V.
+*/
+/**
+ * A typically user-facing description of a bounding box using traditional t/l/r/b
+ *
+ * @public
+ */
+export interface BoundingBox2D {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+/**
+ * A 3D bounding box
+ *
+ * @public
+ */
+export interface BoundingBox3D extends BoundingBox2D {
+    front: number;
+    back: number;
+}
+/**
+ * A description of a single axis using non-axis specific terms to denote the min and max
+ * value of any axis.
+ *
+ * @public
+ */
+export interface Axis {
+    min: number;
+    max: number;
+}
+/**
+ * A description of a bounding box describing each axis individually. This allows us
+ * to treate each axis generically.
+ *
+ * @public
+ */
+export interface AxisBox2D {
+    x: Axis;
+    y: Axis;
+}
+/**
+ * @public
+ */
+export interface AxisBox3D extends AxisBox2D {
+    z: Axis;
+}
+/**
+ * A description of a two-dimensional point
+ *
+ * @public
+ */
+export interface Point2D {
+    x: number;
+    y: number;
+}
+/**
+ * A description of a three-dimensional point
+ *
+ * @public
+ */
+export interface Point3D extends Point2D {
+    z: number;
+}
+/**
+ * A function that accepts a two-dimensional point and returns a new one.
+ *
+ * @public
+ */
+export type TransformPoint2D = (point: Point2D) => Point2D;
+/**
+ * The transform delta that, when applied to Axis a will visually transform it to Axis b
+ * @public
+ */
+export interface AxisDelta {
+    translate: number;
+    scale: number;
+    origin: number;
+    originPoint: number;
+}
+/**
+ * The transform delta that, when applied to Box a will visually transform it to Box b.
+ * @public
+ */
+export interface BoxDelta {
+    x: AxisDelta;
+    y: AxisDelta;
+}