📚 Documentação inicial do ALETHEIA

- MANUAL-PRODUTO.md: Manual do usuário final
- MANUAL-VENDAS.md: Estratégia comercial e vendas
- MANUAL-TECNICO.md: Infraestrutura e deploy
- README.md: Visão geral do projeto

frontend/node_modules/motion-dom/dist/es/view/index.mjs

@@ -0,0 +1,67 @@
+import { noop } from 'motion-utils';
+import { startViewAnimation } from './start.mjs';
+
+/**
+ * TODO:
+ * - Create view transition on next tick
+ * - Replace animations with Motion animations
+ * - Return GroupAnimation on next tick
+ */
+class ViewTransitionBuilder {
+    constructor(update, options = {}) {
+        this.currentTarget = "root";
+        this.targets = new Map();
+        this.notifyReady = noop;
+        this.readyPromise = new Promise((resolve) => {
+            this.notifyReady = resolve;
+        });
+        queueMicrotask(() => {
+            startViewAnimation(update, options, this.targets).then((animation) => this.notifyReady(animation));
+        });
+    }
+    get(selector) {
+        this.currentTarget = selector;
+        return this;
+    }
+    layout(keyframes, options) {
+        this.updateTarget("layout", keyframes, options);
+        return this;
+    }
+    new(keyframes, options) {
+        this.updateTarget("new", keyframes, options);
+        return this;
+    }
+    old(keyframes, options) {
+        this.updateTarget("old", keyframes, options);
+        return this;
+    }
+    enter(keyframes, options) {
+        this.updateTarget("enter", keyframes, options);
+        return this;
+    }
+    exit(keyframes, options) {
+        this.updateTarget("exit", keyframes, options);
+        return this;
+    }
+    crossfade(options) {
+        this.updateTarget("enter", { opacity: 1 }, options);
+        this.updateTarget("exit", { opacity: 0 }, options);
+        return this;
+    }
+    updateTarget(target, keyframes, options = {}) {
+        const { currentTarget, targets } = this;
+        if (!targets.has(currentTarget)) {
+            targets.set(currentTarget, {});
+        }
+        const targetData = targets.get(currentTarget);
+        targetData[target] = { keyframes, options };
+    }
+    then(resolve, reject) {
+        return this.readyPromise.then(resolve, reject);
+    }
+}
+function view(update, defaultOptions = {}) {
+    return new ViewTransitionBuilder(update, defaultOptions);
+}
+
+export { ViewTransitionBuilder, view };

frontend/node_modules/motion-dom/dist/es/view/start.mjs

@@ -0,0 +1,146 @@
+import { secondsToMilliseconds } from 'motion-utils';
+import { BaseGroupPlaybackControls } from '../animation/controls/BaseGroup.mjs';
+import { getValueTransition } from '../animation/utils/get-value-transition.mjs';
+import { NativeAnimationControls } from '../animation/waapi/NativeAnimationControls.mjs';
+import { PseudoAnimation } from '../animation/waapi/PseudoAnimation.mjs';
+import { applyGeneratorOptions } from '../animation/waapi/utils/convert-options.mjs';
+import { mapEasingToNativeEasing } from '../animation/waapi/utils/easing.mjs';
+import { chooseLayerType } from './utils/choose-layer-type.mjs';
+import { css } from './utils/css.mjs';
+import { getLayerName } from './utils/get-layer-name.mjs';
+import { getViewAnimations } from './utils/get-view-animations.mjs';
+import { hasTarget } from './utils/has-target.mjs';
+
+const definitionNames = ["layout", "enter", "exit", "new", "old"];
+function startViewAnimation(update, defaultOptions, targets) {
+    if (!document.startViewTransition) {
+        return new Promise(async (resolve) => {
+            await update();
+            resolve(new BaseGroupPlaybackControls([]));
+        });
+    }
+    // TODO: Go over existing targets and ensure they all have ids
+    /**
+     * If we don't have any animations defined for the root target,
+     * remove it from being captured.
+     */
+    if (!hasTarget("root", targets)) {
+        css.set(":root", {
+            "view-transition-name": "none",
+        });
+    }
+    /**
+     * Set the timing curve to linear for all view transition layers.
+     * This gets baked into the keyframes, which can't be changed
+     * without breaking the generated animation.
+     *
+     * This allows us to set easing via updateTiming - which can be changed.
+     */
+    css.set("::view-transition-group(*), ::view-transition-old(*), ::view-transition-new(*)", { "animation-timing-function": "linear !important" });
+    css.commit(); // Write
+    const transition = document.startViewTransition(async () => {
+        await update();
+        // TODO: Go over new targets and ensure they all have ids
+    });
+    transition.finished.finally(() => {
+        css.remove(); // Write
+    });
+    return new Promise((resolve) => {
+        transition.ready.then(() => {
+            var _a;
+            const generatedViewAnimations = getViewAnimations();
+            const animations = [];
+            /**
+             * Create animations for our definitions
+             */
+            targets.forEach((definition, target) => {
+                // TODO: If target is not "root", resolve elements
+                // and iterate over each
+                for (const key of definitionNames) {
+                    if (!definition[key])
+                        continue;
+                    const { keyframes, options } = definition[key];
+                    for (let [valueName, valueKeyframes] of Object.entries(keyframes)) {
+                        if (!valueKeyframes)
+                            continue;
+                        const valueOptions = {
+                            ...getValueTransition(defaultOptions, valueName),
+                            ...getValueTransition(options, valueName),
+                        };
+                        const type = chooseLayerType(key);
+                        /**
+                         * If this is an opacity animation, and keyframes are not an array,
+                         * we need to convert them into an array and set an initial value.
+                         */
+                        if (valueName === "opacity" &&
+                            !Array.isArray(valueKeyframes)) {
+                            const initialValue = type === "new" ? 0 : 1;
+                            valueKeyframes = [initialValue, valueKeyframes];
+                        }
+                        /**
+                         * Resolve stagger function if provided.
+                         */
+                        if (typeof valueOptions.delay === "function") {
+                            valueOptions.delay = valueOptions.delay(0, 1);
+                        }
+                        const animation = new PseudoAnimation(document.documentElement, `::view-transition-${type}(${target})`, valueName, valueKeyframes, valueOptions);
+                        animations.push(animation);
+                    }
+                }
+            });
+            /**
+             * Handle browser generated animations
+             */
+            for (const animation of generatedViewAnimations) {
+                if (animation.playState === "finished")
+                    continue;
+                const { effect } = animation;
+                if (!effect || !(effect instanceof KeyframeEffect))
+                    continue;
+                const { pseudoElement } = effect;
+                if (!pseudoElement)
+                    continue;
+                const name = getLayerName(pseudoElement);
+                if (!name)
+                    continue;
+                const targetDefinition = targets.get(name.layer);
+                if (!targetDefinition) {
+                    /**
+                     * If transition name is group then update the timing of the animation
+                     * whereas if it's old or new then we could possibly replace it using
+                     * the above method.
+                     */
+                    const transitionName = name.type === "group" ? "layout" : "";
+                    const animationTransition = {
+                        ...getValueTransition(defaultOptions, transitionName),
+                    };
+                    applyGeneratorOptions(animationTransition);
+                    const easing = mapEasingToNativeEasing(animationTransition.ease, animationTransition.duration);
+                    effect.updateTiming({
+                        delay: secondsToMilliseconds((_a = animationTransition.delay) !== null && _a !== void 0 ? _a : 0),
+                        duration: animationTransition.duration,
+                        easing,
+                    });
+                    animations.push(new NativeAnimationControls(animation));
+                }
+                else if (hasOpacity(targetDefinition, "enter") &&
+                    hasOpacity(targetDefinition, "exit") &&
+                    effect
+                        .getKeyframes()
+                        .some((keyframe) => keyframe.mixBlendMode)) {
+                    animations.push(new NativeAnimationControls(animation));
+                }
+                else {
+                    animation.cancel();
+                }
+            }
+            resolve(new BaseGroupPlaybackControls(animations));
+        });
+    });
+}
+function hasOpacity(target, key) {
+    var _a;
+    return (_a = target === null || target === void 0 ? void 0 : target[key]) === null || _a === void 0 ? void 0 : _a.keyframes.opacity;
+}
+
+export { startViewAnimation };

frontend/node_modules/motion-dom/dist/es/view/utils/choose-layer-type.mjs

@@ -0,0 +1,11 @@
+function chooseLayerType(valueName) {
+    if (valueName === "layout")
+        return "group";
+    if (valueName === "enter" || valueName === "new")
+        return "new";
+    if (valueName === "exit" || valueName === "old")
+        return "old";
+    return "group";
+}
+
+export { chooseLayerType };

frontend/node_modules/motion-dom/dist/es/view/utils/css.mjs

@@ -0,0 +1,32 @@
+let pendingRules = {};
+let style = null;
+const css = {
+    set: (selector, values) => {
+        pendingRules[selector] = values;
+    },
+    commit: () => {
+        if (!style) {
+            style = document.createElement("style");
+            style.id = "motion-view";
+        }
+        let cssText = "";
+        for (const selector in pendingRules) {
+            const rule = pendingRules[selector];
+            cssText += `${selector} {\n`;
+            for (const [property, value] of Object.entries(rule)) {
+                cssText += `  ${property}: ${value};\n`;
+            }
+            cssText += "}\n";
+        }
+        style.textContent = cssText;
+        document.head.appendChild(style);
+        pendingRules = {};
+    },
+    remove: () => {
+        if (style && style.parentElement) {
+            style.parentElement.removeChild(style);
+        }
+    },
+};
+
+export { css };

frontend/node_modules/motion-dom/dist/es/view/utils/get-layer-name.mjs

@@ -0,0 +1,8 @@
+function getLayerName(pseudoElement) {
+    const match = pseudoElement.match(/::view-transition-(old|new|group|image-pair)\((.*?)\)/);
+    if (!match)
+        return null;
+    return { layer: match[2], type: match[1] };
+}
+
+export { getLayerName };

frontend/node_modules/motion-dom/dist/es/view/utils/get-view-animations.mjs

@@ -0,0 +1,13 @@
+function filterViewAnimations(animation) {
+    var _a;
+    const { effect } = animation;
+    if (!effect)
+        return false;
+    return (effect.target === document.documentElement &&
+        ((_a = effect.pseudoElement) === null || _a === void 0 ? void 0 : _a.startsWith("::view-transition")));
+}
+function getViewAnimations() {
+    return document.getAnimations().filter(filterViewAnimations);
+}
+
+export { getViewAnimations };

frontend/node_modules/motion-dom/dist/es/view/utils/has-target.mjs

@@ -0,0 +1,5 @@
+function hasTarget(target, targets) {
+    return targets.has(target) && Object.keys(targets.get(target)).length > 0;
+}
+
+export { hasTarget };