@teamturing/react-kit 2.3.1 → 2.5.0

package/esm/node_modules/framer-motion/dist/es/render/html/HTMLVisualElement.js

@@ -0,0 +1,55 @@
+import { buildHTMLStyles } from './utils/build-styles.js';
+import { isCSSVariableName } from '../dom/utils/is-css-variable.js';
+import { transformProps } from './utils/transform.js';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';
+import { renderHTML } from './utils/render.js';
+import { getDefaultValueType } from '../dom/value-types/defaults.js';
+import { measureViewportBox } from '../../projection/utils/measure.js';
+import { DOMVisualElement } from '../dom/DOMVisualElement.js';
+import { isMotionValue } from '../../value/utils/is-motion-value.js';
+
+function getComputedStyle(element) {
+    return window.getComputedStyle(element);
+}
+class HTMLVisualElement extends DOMVisualElement {
+    readValueFromInstance(instance, key) {
+        if (transformProps.has(key)) {
+            const defaultType = getDefaultValueType(key);
+            return defaultType ? defaultType.default || 0 : 0;
+        }
+        else {
+            const computedStyle = getComputedStyle(instance);
+            const value = (isCSSVariableName(key)
+                ? computedStyle.getPropertyValue(key)
+                : computedStyle[key]) || 0;
+            return typeof value === "string" ? value.trim() : value;
+        }
+    }
+    measureInstanceViewportBox(instance, { transformPagePoint }) {
+        return measureViewportBox(instance, transformPagePoint);
+    }
+    build(renderState, latestValues, options, props) {
+        buildHTMLStyles(renderState, latestValues, options, props.transformTemplate);
+    }
+    scrapeMotionValuesFromProps(props, prevProps) {
+        return scrapeMotionValuesFromProps(props, prevProps);
+    }
+    handleChildMotionValue() {
+        if (this.childSubscription) {
+            this.childSubscription();
+            delete this.childSubscription;
+        }
+        const { children } = this.props;
+        if (isMotionValue(children)) {
+            this.childSubscription = children.on("change", (latest) => {
+                if (this.current)
+                    this.current.textContent = `${latest}`;
+            });
+        }
+    }
+    renderInstance(instance, renderState, styleProp, projection) {
+        renderHTML(instance, renderState, styleProp, projection);
+    }
+}
+
+export { HTMLVisualElement, getComputedStyle };

package/esm/node_modules/framer-motion/dist/es/render/html/config-motion.js

@@ -0,0 +1,12 @@
+import { makeUseVisualState } from '../../motion/utils/use-visual-state.js';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';
+import { createHtmlRenderState } from './utils/create-render-state.js';
+
+const htmlMotionConfig = {
+    useVisualState: makeUseVisualState({
+        scrapeMotionValuesFromProps,
+        createRenderState: createHtmlRenderState,
+    }),
+};
+
+export { htmlMotionConfig };

package/esm/node_modules/framer-motion/dist/es/render/html/use-props.js

@@ -0,0 +1,57 @@
+import { useMemo } from 'react';
+import { isForcedMotionValue } from '../../motion/utils/is-forced-motion-value.js';
+import { isMotionValue } from '../../value/utils/is-motion-value.js';
+import { buildHTMLStyles } from './utils/build-styles.js';
+import { createHtmlRenderState } from './utils/create-render-state.js';
+
+function copyRawValuesOnly(target, source, props) {
+    for (const key in source) {
+        if (!isMotionValue(source[key]) && !isForcedMotionValue(key, props)) {
+            target[key] = source[key];
+        }
+    }
+}
+function useInitialMotionValues({ transformTemplate }, visualState, isStatic) {
+    return useMemo(() => {
+        const state = createHtmlRenderState();
+        buildHTMLStyles(state, visualState, { enableHardwareAcceleration: !isStatic }, transformTemplate);
+        return Object.assign({}, state.vars, state.style);
+    }, [visualState]);
+}
+function useStyle(props, visualState, isStatic) {
+    const styleProp = props.style || {};
+    const style = {};
+    /**
+     * Copy non-Motion Values straight into style
+     */
+    copyRawValuesOnly(style, styleProp, props);
+    Object.assign(style, useInitialMotionValues(props, visualState, isStatic));
+    return props.transformValues ? props.transformValues(style) : style;
+}
+function useHTMLProps(props, visualState, isStatic) {
+    // The `any` isn't ideal but it is the type of createElement props argument
+    const htmlProps = {};
+    const style = useStyle(props, visualState, isStatic);
+    if (props.drag && props.dragListener !== false) {
+        // Disable the ghost element when a user drags
+        htmlProps.draggable = false;
+        // Disable text selection
+        style.userSelect =
+            style.WebkitUserSelect =
+                style.WebkitTouchCallout =
+                    "none";
+        // Disable scrolling on the draggable direction
+        style.touchAction =
+            props.drag === true
+                ? "none"
+                : `pan-${props.drag === "x" ? "y" : "x"}`;
+    }
+    if (props.tabIndex === undefined &&
+        (props.onTap || props.onTapStart || props.whileTap)) {
+        htmlProps.tabIndex = 0;
+    }
+    htmlProps.style = style;
+    return htmlProps;
+}
+
+export { copyRawValuesOnly, useHTMLProps };

package/esm/node_modules/framer-motion/dist/es/render/html/utils/build-styles.js

@@ -0,0 +1,74 @@
+import { buildTransform } from './build-transform.js';
+import { isCSSVariableName } from '../../dom/utils/is-css-variable.js';
+import { transformProps } from './transform.js';
+import { getValueAsType } from '../../dom/value-types/get-as-type.js';
+import { numberValueTypes } from '../../dom/value-types/number.js';
+
+function buildHTMLStyles(state, latestValues, options, transformTemplate) {
+    const { style, vars, transform, transformOrigin } = state;
+    // Track whether we encounter any transform or transformOrigin values.
+    let hasTransform = false;
+    let hasTransformOrigin = false;
+    // Does the calculated transform essentially equal "none"?
+    let transformIsNone = true;
+    /**
+     * Loop over all our latest animated values and decide whether to handle them
+     * as a style or CSS variable.
+     *
+     * Transforms and transform origins are kept seperately for further processing.
+     */
+    for (const key in latestValues) {
+        const value = latestValues[key];
+        /**
+         * If this is a CSS variable we don't do any further processing.
+         */
+        if (isCSSVariableName(key)) {
+            vars[key] = value;
+            continue;
+        }
+        // Convert the value to its default value type, ie 0 -> "0px"
+        const valueType = numberValueTypes[key];
+        const valueAsType = getValueAsType(value, valueType);
+        if (transformProps.has(key)) {
+            // If this is a transform, flag to enable further transform processing
+            hasTransform = true;
+            transform[key] = valueAsType;
+            // If we already know we have a non-default transform, early return
+            if (!transformIsNone)
+                continue;
+            // Otherwise check to see if this is a default transform
+            if (value !== (valueType.default || 0))
+                transformIsNone = false;
+        }
+        else if (key.startsWith("origin")) {
+            // If this is a transform origin, flag and enable further transform-origin processing
+            hasTransformOrigin = true;
+            transformOrigin[key] = valueAsType;
+        }
+        else {
+            style[key] = valueAsType;
+        }
+    }
+    if (!latestValues.transform) {
+        if (hasTransform || transformTemplate) {
+            style.transform = buildTransform(state.transform, options, transformIsNone, transformTemplate);
+        }
+        else if (style.transform) {
+            /**
+             * If we have previously created a transform but currently don't have any,
+             * reset transform style to none.
+             */
+            style.transform = "none";
+        }
+    }
+    /**
+     * Build a transformOrigin style. Uses the same defaults as the browser for
+     * undefined origins.
+     */
+    if (hasTransformOrigin) {
+        const { originX = "50%", originY = "50%", originZ = 0, } = transformOrigin;
+        style.transformOrigin = `${originX} ${originY} ${originZ}`;
+    }
+}
+
+export { buildHTMLStyles };

package/esm/node_modules/framer-motion/dist/es/render/html/utils/build-transform.js

@@ -0,0 +1,45 @@
+import { transformPropOrder } from './transform.js';
+
+const translateAlias = {
+    x: "translateX",
+    y: "translateY",
+    z: "translateZ",
+    transformPerspective: "perspective",
+};
+const numTransforms = transformPropOrder.length;
+/**
+ * Build a CSS transform style from individual x/y/scale etc properties.
+ *
+ * This outputs with a default order of transforms/scales/rotations, this can be customised by
+ * providing a transformTemplate function.
+ */
+function buildTransform(transform, { enableHardwareAcceleration = true, allowTransformNone = true, }, transformIsDefault, transformTemplate) {
+    // The transform string we're going to build into.
+    let transformString = "";
+    /**
+     * Loop over all possible transforms in order, adding the ones that
+     * are present to the transform string.
+     */
+    for (let i = 0; i < numTransforms; i++) {
+        const key = transformPropOrder[i];
+        if (transform[key] !== undefined) {
+            const transformName = translateAlias[key] || key;
+            transformString += `${transformName}(${transform[key]}) `;
+        }
+    }
+    if (enableHardwareAcceleration && !transform.z) {
+        transformString += "translateZ(0)";
+    }
+    transformString = transformString.trim();
+    // If we have a custom `transform` template, pass our transform values and
+    // generated transformString to that before returning
+    if (transformTemplate) {
+        transformString = transformTemplate(transform, transformIsDefault ? "" : transformString);
+    }
+    else if (allowTransformNone && transformIsDefault) {
+        transformString = "none";
+    }
+    return transformString;
+}
+
+export { buildTransform };

package/esm/node_modules/framer-motion/dist/es/render/html/utils/create-render-state.js

@@ -0,0 +1,8 @@
+const createHtmlRenderState = () => ({
+    style: {},
+    transform: {},
+    transformOrigin: {},
+    vars: {},
+});
+
+export { createHtmlRenderState };

package/esm/node_modules/framer-motion/dist/es/render/html/utils/render.js

@@ -0,0 +1,9 @@
+function renderHTML(element, { style, vars }, styleProp, projection) {
+    Object.assign(element.style, style, projection && projection.getProjectionStyles(styleProp));
+    // Loop over any CSS variables and assign those.
+    for (const key in vars) {
+        element.style.setProperty(key, vars[key]);
+    }
+}
+
+export { renderHTML };

package/esm/node_modules/framer-motion/dist/es/render/html/utils/scrape-motion-values.js

@@ -0,0 +1,17 @@
+import { isForcedMotionValue } from '../../../motion/utils/is-forced-motion-value.js';
+import { isMotionValue } from '../../../value/utils/is-motion-value.js';
+
+function scrapeMotionValuesFromProps(props, prevProps) {
+    const { style } = props;
+    const newValues = {};
+    for (const key in style) {
+        if (isMotionValue(style[key]) ||
+            (prevProps.style && isMotionValue(prevProps.style[key])) ||
+            isForcedMotionValue(key, props)) {
+            newValues[key] = style[key];
+        }
+    }
+    return newValues;
+}
+
+export { scrapeMotionValuesFromProps };

package/esm/node_modules/framer-motion/dist/es/render/html/utils/transform.js

@@ -0,0 +1,28 @@
+/**
+ * Generate a list of every possible transform key.
+ */
+const transformPropOrder = [
+    "transformPerspective",
+    "x",
+    "y",
+    "z",
+    "translateX",
+    "translateY",
+    "translateZ",
+    "scale",
+    "scaleX",
+    "scaleY",
+    "rotate",
+    "rotateX",
+    "rotateY",
+    "rotateZ",
+    "skew",
+    "skewX",
+    "skewY",
+];
+/**
+ * A quick lookup for transform props.
+ */
+const transformProps = new Set(transformPropOrder);
+
+export { transformPropOrder, transformProps };

package/esm/node_modules/framer-motion/dist/es/render/store.js

@@ -0,0 +1,3 @@
+const visualElementStore = new WeakMap();
+
+export { visualElementStore };

package/esm/node_modules/framer-motion/dist/es/render/svg/SVGVisualElement.js

@@ -0,0 +1,46 @@
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';
+import { DOMVisualElement } from '../dom/DOMVisualElement.js';
+import { buildSVGAttrs } from './utils/build-attrs.js';
+import { camelToDash } from '../dom/utils/camel-to-dash.js';
+import { camelCaseAttributes } from './utils/camel-case-attrs.js';
+import { transformProps } from '../html/utils/transform.js';
+import { renderSVG } from './utils/render.js';
+import { getDefaultValueType } from '../dom/value-types/defaults.js';
+import { createBox } from '../../projection/geometry/models.js';
+import { isSVGTag } from './utils/is-svg-tag.js';
+
+class SVGVisualElement extends DOMVisualElement {
+    constructor() {
+        super(...arguments);
+        this.isSVGTag = false;
+    }
+    getBaseTargetFromProps(props, key) {
+        return props[key];
+    }
+    readValueFromInstance(instance, key) {
+        if (transformProps.has(key)) {
+            const defaultType = getDefaultValueType(key);
+            return defaultType ? defaultType.default || 0 : 0;
+        }
+        key = !camelCaseAttributes.has(key) ? camelToDash(key) : key;
+        return instance.getAttribute(key);
+    }
+    measureInstanceViewportBox() {
+        return createBox();
+    }
+    scrapeMotionValuesFromProps(props, prevProps) {
+        return scrapeMotionValuesFromProps(props, prevProps);
+    }
+    build(renderState, latestValues, options, props) {
+        buildSVGAttrs(renderState, latestValues, options, this.isSVGTag, props.transformTemplate);
+    }
+    renderInstance(instance, renderState, styleProp, projection) {
+        renderSVG(instance, renderState, styleProp, projection);
+    }
+    mount(instance) {
+        this.isSVGTag = isSVGTag(instance.tagName);
+        super.mount(instance);
+    }
+}
+
+export { SVGVisualElement };

package/esm/node_modules/framer-motion/dist/es/render/svg/config-motion.js

@@ -0,0 +1,40 @@
+import { renderSVG } from './utils/render.js';
+import { scrapeMotionValuesFromProps } from './utils/scrape-motion-values.js';
+import { makeUseVisualState } from '../../motion/utils/use-visual-state.js';
+import { createSvgRenderState } from './utils/create-render-state.js';
+import { buildSVGAttrs } from './utils/build-attrs.js';
+import { isSVGTag } from './utils/is-svg-tag.js';
+import { frame } from '../../frameloop/frame.js';
+
+const svgMotionConfig = {
+    useVisualState: makeUseVisualState({
+        scrapeMotionValuesFromProps: scrapeMotionValuesFromProps,
+        createRenderState: createSvgRenderState,
+        onMount: (props, instance, { renderState, latestValues }) => {
+            frame.read(() => {
+                try {
+                    renderState.dimensions =
+                        typeof instance.getBBox ===
+                            "function"
+                            ? instance.getBBox()
+                            : instance.getBoundingClientRect();
+                }
+                catch (e) {
+                    // Most likely trying to measure an unrendered element under Firefox
+                    renderState.dimensions = {
+                        x: 0,
+                        y: 0,
+                        width: 0,
+                        height: 0,
+                    };
+                }
+            });
+            frame.render(() => {
+                buildSVGAttrs(renderState, latestValues, { enableHardwareAcceleration: false }, isSVGTag(instance.tagName), props.transformTemplate);
+                renderSVG(instance, renderState);
+            });
+        },
+    }),
+};
+
+export { svgMotionConfig };

package/esm/node_modules/framer-motion/dist/es/render/svg/lowercase-elements.js

@@ -0,0 +1,33 @@
+/**
+ * We keep these listed seperately as we use the lowercase tag names as part
+ * of the runtime bundle to detect SVG components
+ */
+const lowercaseSVGElements = [
+    "animate",
+    "circle",
+    "defs",
+    "desc",
+    "ellipse",
+    "g",
+    "image",
+    "line",
+    "filter",
+    "marker",
+    "mask",
+    "metadata",
+    "path",
+    "pattern",
+    "polygon",
+    "polyline",
+    "rect",
+    "stop",
+    "switch",
+    "symbol",
+    "svg",
+    "text",
+    "tspan",
+    "use",
+    "view",
+];
+
+export { lowercaseSVGElements };

package/esm/node_modules/framer-motion/dist/es/render/svg/use-props.js

@@ -0,0 +1,24 @@
+import { useMemo } from 'react';
+import { copyRawValuesOnly } from '../html/use-props.js';
+import { buildSVGAttrs } from './utils/build-attrs.js';
+import { createSvgRenderState } from './utils/create-render-state.js';
+import { isSVGTag } from './utils/is-svg-tag.js';
+
+function useSVGProps(props, visualState, _isStatic, Component) {
+    const visualProps = useMemo(() => {
+        const state = createSvgRenderState();
+        buildSVGAttrs(state, visualState, { enableHardwareAcceleration: false }, isSVGTag(Component), props.transformTemplate);
+        return {
+            ...state.attrs,
+            style: { ...state.style },
+        };
+    }, [visualState]);
+    if (props.style) {
+        const rawStyles = {};
+        copyRawValuesOnly(rawStyles, props.style, props);
+        visualProps.style = { ...rawStyles, ...visualProps.style };
+    }
+    return visualProps;
+}
+
+export { useSVGProps };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/build-attrs.js

@@ -0,0 +1,52 @@
+import { buildHTMLStyles } from '../../html/utils/build-styles.js';
+import { calcSVGTransformOrigin } from './transform-origin.js';
+import { buildSVGPath } from './path.js';
+
+/**
+ * Build SVG visual attrbutes, like cx and style.transform
+ */
+function buildSVGAttrs(state, { attrX, attrY, attrScale, originX, originY, pathLength, pathSpacing = 1, pathOffset = 0, 
+// This is object creation, which we try to avoid per-frame.
+...latest }, options, isSVGTag, transformTemplate) {
+    buildHTMLStyles(state, latest, options, transformTemplate);
+    /**
+     * For svg tags we just want to make sure viewBox is animatable and treat all the styles
+     * as normal HTML tags.
+     */
+    if (isSVGTag) {
+        if (state.style.viewBox) {
+            state.attrs.viewBox = state.style.viewBox;
+        }
+        return;
+    }
+    state.attrs = state.style;
+    state.style = {};
+    const { attrs, style, dimensions } = state;
+    /**
+     * However, we apply transforms as CSS transforms. So if we detect a transform we take it from attrs
+     * and copy it into style.
+     */
+    if (attrs.transform) {
+        if (dimensions)
+            style.transform = attrs.transform;
+        delete attrs.transform;
+    }
+    // Parse transformOrigin
+    if (dimensions &&
+        (originX !== undefined || originY !== undefined || style.transform)) {
+        style.transformOrigin = calcSVGTransformOrigin(dimensions, originX !== undefined ? originX : 0.5, originY !== undefined ? originY : 0.5);
+    }
+    // Render attrX/attrY/attrScale as attributes
+    if (attrX !== undefined)
+        attrs.x = attrX;
+    if (attrY !== undefined)
+        attrs.y = attrY;
+    if (attrScale !== undefined)
+        attrs.scale = attrScale;
+    // Build SVG path if one has been defined
+    if (pathLength !== undefined) {
+        buildSVGPath(attrs, pathLength, pathSpacing, pathOffset, false);
+    }
+}
+
+export { buildSVGAttrs };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/camel-case-attrs.js

@@ -0,0 +1,30 @@
+/**
+ * A set of attribute names that are always read/written as camel case.
+ */
+const camelCaseAttributes = new Set([
+    "baseFrequency",
+    "diffuseConstant",
+    "kernelMatrix",
+    "kernelUnitLength",
+    "keySplines",
+    "keyTimes",
+    "limitingConeAngle",
+    "markerHeight",
+    "markerWidth",
+    "numOctaves",
+    "targetX",
+    "targetY",
+    "surfaceScale",
+    "specularConstant",
+    "specularExponent",
+    "stdDeviation",
+    "tableValues",
+    "viewBox",
+    "gradientTransform",
+    "pathLength",
+    "startOffset",
+    "textLength",
+    "lengthAdjust",
+]);
+
+export { camelCaseAttributes };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/create-render-state.js

@@ -0,0 +1,8 @@
+import { createHtmlRenderState } from '../../html/utils/create-render-state.js';
+
+const createSvgRenderState = () => ({
+    ...createHtmlRenderState(),
+    attrs: {},
+});
+
+export { createSvgRenderState };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/is-svg-tag.js

@@ -0,0 +1,3 @@
+const isSVGTag = (tag) => typeof tag === "string" && tag.toLowerCase() === "svg";
+
+export { isSVGTag };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/path.js

@@ -0,0 +1,32 @@
+import { px } from '../../../value/types/numbers/units.js';
+
+const dashKeys = {
+    offset: "stroke-dashoffset",
+    array: "stroke-dasharray",
+};
+const camelKeys = {
+    offset: "strokeDashoffset",
+    array: "strokeDasharray",
+};
+/**
+ * Build SVG path properties. Uses the path's measured length to convert
+ * our custom pathLength, pathSpacing and pathOffset into stroke-dashoffset
+ * and stroke-dasharray attributes.
+ *
+ * This function is mutative to reduce per-frame GC.
+ */
+function buildSVGPath(attrs, length, spacing = 1, offset = 0, useDashCase = true) {
+    // Normalise path length by setting SVG attribute pathLength to 1
+    attrs.pathLength = 1;
+    // We use dash case when setting attributes directly to the DOM node and camel case
+    // when defining props on a React component.
+    const keys = useDashCase ? dashKeys : camelKeys;
+    // Build the dash offset
+    attrs[keys.offset] = px.transform(-offset);
+    // Build the dash array
+    const pathLength = px.transform(length);
+    const pathSpacing = px.transform(spacing);
+    attrs[keys.array] = `${pathLength} ${pathSpacing}`;
+}
+
+export { buildSVGPath };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/render.js

@@ -0,0 +1,12 @@
+import { camelToDash } from '../../dom/utils/camel-to-dash.js';
+import { renderHTML } from '../../html/utils/render.js';
+import { camelCaseAttributes } from './camel-case-attrs.js';
+
+function renderSVG(element, renderState, _styleProp, projection) {
+    renderHTML(element, renderState, undefined, projection);
+    for (const key in renderState.attrs) {
+        element.setAttribute(!camelCaseAttributes.has(key) ? camelToDash(key) : key, renderState.attrs[key]);
+    }
+}
+
+export { renderSVG };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/scrape-motion-values.js

@@ -0,0 +1,18 @@
+import { isMotionValue } from '../../../value/utils/is-motion-value.js';
+import { scrapeMotionValuesFromProps as scrapeMotionValuesFromProps$1 } from '../../html/utils/scrape-motion-values.js';
+import { transformPropOrder } from '../../html/utils/transform.js';
+
+function scrapeMotionValuesFromProps(props, prevProps) {
+    const newValues = scrapeMotionValuesFromProps$1(props, prevProps);
+    for (const key in props) {
+        if (isMotionValue(props[key]) || isMotionValue(prevProps[key])) {
+            const targetKey = transformPropOrder.indexOf(key) !== -1
+                ? "attr" + key.charAt(0).toUpperCase() + key.substring(1)
+                : key;
+            newValues[targetKey] = props[key];
+        }
+    }
+    return newValues;
+}
+
+export { scrapeMotionValuesFromProps };

package/esm/node_modules/framer-motion/dist/es/render/svg/utils/transform-origin.js

@@ -0,0 +1,18 @@
+import { px } from '../../../value/types/numbers/units.js';
+
+function calcOrigin(origin, offset, size) {
+    return typeof origin === "string"
+        ? origin
+        : px.transform(offset + size * origin);
+}
+/**
+ * The SVG transform origin defaults are different to CSS and is less intuitive,
+ * so we use the measured dimensions of the SVG to reconcile these.
+ */
+function calcSVGTransformOrigin(dimensions, originX, originY) {
+    const pxOriginX = calcOrigin(originX, dimensions.x, dimensions.width);
+    const pxOriginY = calcOrigin(originY, dimensions.y, dimensions.height);
+    return `${pxOriginX} ${pxOriginY}`;
+}
+
+export { calcSVGTransformOrigin };