@hawsen-the-first/interactiv 0.0.1

package/dist/src/settingsManager.js

@@ -0,0 +1,317 @@
+import { stateManager } from "./stateManager";
+import { logger } from "./logger";
+const log = logger;
+export class SettingsManager {
+    eventBus;
+    orchestrator;
+    navigationManager;
+    config = null;
+    isSettingsActive = false;
+    lastActiveViewId = null;
+    touchSequenceState = {
+        step: 0,
+        lastTouchTime: 0,
+    };
+    lastEventTime = 0; // Track last event to prevent duplicates
+    touchListeners = [];
+    // Default configuration values
+    DEFAULT_CORNER_RADIUS = 100;
+    DEFAULT_TOUCH_TIMEOUT = 3000;
+    EVENT_DEBOUNCE_MS = 50; // Ignore events within 50ms of each other
+    constructor(orchestrator, navigationManager) {
+        this.orchestrator = orchestrator;
+        this.navigationManager = navigationManager;
+        this.eventBus = orchestrator.registerEventBus("settings-manager");
+        this.setupEventListeners();
+        this.initializeGlobalState();
+    }
+    initializeGlobalState() {
+        if (!stateManager.has("settings.isActive")) {
+            stateManager.set("settings.isActive", false);
+        }
+        if (!stateManager.has("settings.lastActiveViewId")) {
+            stateManager.set("settings.lastActiveViewId", null);
+        }
+    }
+    setupEventListeners() {
+        this.eventBus.on("register-settings", (e) => {
+            const { config } = e.detail;
+            this.registerSettings(config);
+        });
+        this.eventBus.on("activate-settings", () => {
+            this.activateSettings();
+        });
+        this.eventBus.on("deactivate-settings", () => {
+            this.deactivateSettings();
+        });
+        // Listen for navigation changes to track active views
+        const navBus = this.orchestrator.getEventBus("navigation-manager");
+        if (navBus) {
+            navBus.on("view-changed", (e) => {
+                const { newViewId } = e.detail;
+                if (!this.isSettingsActive && newViewId !== this.config?.view.componentId) {
+                    this.lastActiveViewId = newViewId;
+                    stateManager.set("settings.lastActiveViewId", newViewId);
+                }
+            });
+        }
+    }
+    registerSettings(config) {
+        this.validateConfig(config);
+        // Clean up existing settings if any
+        if (this.config) {
+            this.cleanup();
+        }
+        this.config = {
+            ...config,
+            exitBehavior: config.exitBehavior || "reset",
+            cornerTouchRadius: config.cornerTouchRadius || this.DEFAULT_CORNER_RADIUS,
+            touchTimeout: config.touchTimeout || this.DEFAULT_TOUCH_TIMEOUT,
+            debugMode: config.debugMode || false,
+            transitionConfig: config.transitionConfig || {
+                type: "fade",
+                duration: 500,
+            },
+        };
+        // Register the settings view with navigation manager
+        const navBus = this.orchestrator.getEventBus("navigation-manager");
+        if (navBus) {
+            navBus.emit("register-view", { view: this.config.view });
+        }
+        this.setupCornerTouchListeners();
+        this.resetTouchSequence();
+        log.trace(`Settings registered with corner touch activation (radius: ${this.config.cornerTouchRadius}px, timeout: ${this.config.touchTimeout}ms)`);
+    }
+    validateConfig(config) {
+        if (!config.view) {
+            throw new Error("Settings view is required");
+        }
+        if (config.exitBehavior === "reset" && !config.startingViewId) {
+            throw new Error('startingViewId is required when exitBehavior is "reset"');
+        }
+        if (config.exitBehavior && !["reset", "return"].includes(config.exitBehavior)) {
+            throw new Error('exitBehavior must be either "reset" or "return"');
+        }
+        if (config.cornerTouchRadius && config.cornerTouchRadius <= 0) {
+            throw new Error("cornerTouchRadius must be greater than 0");
+        }
+        if (config.touchTimeout && config.touchTimeout <= 0) {
+            throw new Error("touchTimeout must be greater than 0");
+        }
+    }
+    setupCornerTouchListeners() {
+        if (!this.config)
+            return;
+        const touchHandler = (event) => {
+            if (event instanceof TouchEvent || event instanceof MouseEvent) {
+                this.handleTouchAttempt(event);
+            }
+        };
+        // Add listeners for both touch and mouse events
+        const eventTypes = ["touchstart"];
+        eventTypes.forEach((eventType) => {
+            const listener = touchHandler.bind(this);
+            document.addEventListener(eventType, listener, { passive: true });
+            this.touchListeners.push({
+                element: document,
+                type: eventType,
+                listener,
+            });
+        });
+    }
+    handleTouchAttempt(event) {
+        if (!this.config)
+            return;
+        const now = Date.now();
+        // Prevent duplicate events (touchstart + mousedown on same interaction)
+        if (now - this.lastEventTime < this.EVENT_DEBOUNCE_MS) {
+            log.trace("Ignoring duplicate event within debounce window");
+            return;
+        }
+        this.lastEventTime = now;
+        // Get touch/click coordinates
+        let x, y;
+        if (event instanceof TouchEvent && event.touches.length > 0) {
+            x = event.touches[0].clientX;
+            y = event.touches[0].clientY;
+        }
+        else if (event instanceof MouseEvent) {
+            x = event.clientX;
+            y = event.clientY;
+        }
+        else {
+            return;
+        }
+        const timeSinceLastTouch = now - this.touchSequenceState.lastTouchTime;
+        // Check if timeout exceeded
+        if (this.touchSequenceState.step > 0 && timeSinceLastTouch > this.config.touchTimeout) {
+            log.trace("Touch sequence timed out, resetting");
+            this.resetTouchSequence();
+        }
+        const cornerDetected = this.detectCornerTouch(x, y);
+        if (cornerDetected === null) {
+            // Touch outside corner zones - reset sequence
+            if (this.touchSequenceState.step > 0) {
+                log.trace("Touch outside corner zones, resetting sequence");
+                this.resetTouchSequence();
+            }
+            return;
+        }
+        // Check if the correct corner was touched based on current step
+        const expectedCorner = this.getExpectedCorner();
+        if (cornerDetected === expectedCorner) {
+            log.trace(`Correct corner touched: ${cornerDetected} (step ${this.touchSequenceState.step + 1}/3)`);
+            this.touchSequenceState.step++;
+            this.touchSequenceState.lastTouchTime = now;
+            // Check if sequence is complete
+            if (this.touchSequenceState.step === 3) {
+                log.trace("Touch sequence complete! Activating settings...");
+                this.activateSettings();
+                this.resetTouchSequence();
+            }
+        }
+        else {
+            // Wrong corner touched - reset sequence
+            log.trace(`Wrong corner touched: expected ${expectedCorner}, got ${cornerDetected}. Resetting sequence.`);
+            this.resetTouchSequence();
+        }
+    }
+    detectCornerTouch(x, y) {
+        if (!this.config)
+            return null;
+        const radius = this.config.cornerTouchRadius;
+        const width = window.innerWidth;
+        const height = window.innerHeight;
+        // Top-left corner
+        if (x < radius && y < radius) {
+            log.trace("top-left touch", [x, y, radius]);
+            return "top-left";
+        }
+        // Top-right corner
+        if (x > width - radius && y < radius) {
+            log.trace("top-right touch");
+            return "top-right";
+        }
+        // Bottom-right corner
+        if (x > width - radius && y > height - radius) {
+            log.trace("bottom-right touch");
+            return "bottom-right";
+        }
+        return null;
+    }
+    getExpectedCorner() {
+        switch (this.touchSequenceState.step) {
+            case 0:
+                return "top-left";
+            case 1:
+                return "top-right";
+            case 2:
+                return "bottom-right";
+            default:
+                return "top-left";
+        }
+    }
+    resetTouchSequence() {
+        this.touchSequenceState = {
+            step: 0,
+            lastTouchTime: 0,
+        };
+        this.lastEventTime = 0; // Reset debounce timer as well
+    }
+    async activateSettings() {
+        if (!this.config || this.isSettingsActive)
+            return;
+        log.trace("Activating settings");
+        // Store the current view before switching to settings
+        const currentViewId = this.navigationManager.getCurrentViewId();
+        if (currentViewId && currentViewId !== this.config.view.componentId) {
+            this.lastActiveViewId = currentViewId;
+            stateManager.set("settings.lastActiveViewId", currentViewId);
+        }
+        this.isSettingsActive = true;
+        stateManager.set("settings.isActive", true);
+        try {
+            await this.navigationManager.navigateToView(this.config.view.componentId, this.config.transitionConfig);
+            this.eventBus.emit("settings-activated", {
+                viewId: this.config.view.componentId,
+                previousViewId: this.lastActiveViewId,
+            });
+        }
+        catch (error) {
+            log.error("Failed to activate settings:", error);
+            this.isSettingsActive = false;
+            stateManager.set("settings.isActive", false);
+        }
+    }
+    async handleSettingsExit() {
+        if (!this.config || !this.isSettingsActive)
+            return;
+        log.trace(`Exiting settings with '${this.config.exitBehavior}' behavior`);
+        this.isSettingsActive = false;
+        stateManager.set("settings.isActive", false);
+        let targetViewId = null;
+        if (this.config.exitBehavior === "return" && this.lastActiveViewId) {
+            targetViewId = this.lastActiveViewId;
+        }
+        else if (this.config.exitBehavior === "reset" && this.config.startingViewId) {
+            targetViewId = this.config.startingViewId;
+        }
+        if (targetViewId) {
+            try {
+                await this.navigationManager.navigateToView(targetViewId, this.config.transitionConfig);
+                this.eventBus.emit("settings-deactivated", {
+                    targetViewId,
+                    exitBehavior: this.config.exitBehavior,
+                });
+            }
+            catch (error) {
+                log.error("Failed to exit settings:", error);
+                // Reset state on error
+                this.isSettingsActive = true;
+                stateManager.set("settings.isActive", true);
+            }
+        }
+        else {
+            log.warn("No target view available for settings exit");
+        }
+    }
+    async deactivateSettings() {
+        await this.handleSettingsExit();
+    }
+    isActive() {
+        return this.isSettingsActive;
+    }
+    getCurrentConfig() {
+        return this.config;
+    }
+    getLastActiveViewId() {
+        return this.lastActiveViewId;
+    }
+    // Manual control methods
+    forceActivate() {
+        this.resetTouchSequence();
+        this.activateSettings();
+    }
+    forceDeactivate() {
+        this.deactivateSettings();
+    }
+    resetSequence() {
+        this.resetTouchSequence();
+    }
+    cleanup() {
+        // Remove all touch listeners
+        this.touchListeners.forEach(({ element, type, listener }) => {
+            element.removeEventListener(type, listener);
+        });
+        this.touchListeners.length = 0;
+        this.isSettingsActive = false;
+        stateManager.set("settings.isActive", false);
+        this.resetTouchSequence();
+    }
+    destroy() {
+        this.cleanup();
+        this.config = null;
+        this.lastActiveViewId = null;
+        log.trace("SettingsManager destroyed");
+    }
+}

package/dist/src/stateManager.d.ts

@@ -0,0 +1,58 @@
+interface StoreParams {
+    mutations?: object;
+    state?: Store;
+    status?: string;
+    events?: object;
+}
+export interface StateSubscription {
+    unsubscribe: () => void;
+}
+export declare class Store {
+    private mutations;
+    private state;
+    private status;
+    private events;
+    private stateSubscriptions;
+    constructor(params: StoreParams);
+    getStateObject(): any;
+    getStateValue(key: string): any;
+    setStateValue(key: string, value: any): void;
+    subscribeToKey(key: string, callback: (value: any, key: string) => void): StateSubscription;
+    mutateStore(mutationKey: string, payload: any): boolean;
+}
+declare const globalStore: Store;
+export declare class ComponentStateManager {
+    private localState;
+    private stateSubscriptions;
+    private onStateChange;
+    private stateProxy;
+    constructor(_: string, onStateChange: (key: string, value: any, isLocal: boolean) => void);
+    private createStateProxy;
+    getStateProxy(): any;
+    defineState(initialState: Record<string, any>): void;
+    useState<T>(key: string, initialValue: T): [T, (newValue: T) => void];
+    useGlobalState<T>(key: string, initialValue?: T): [T, (newValue: T) => void];
+    getLocalState(key: string): any;
+    destroy(): void;
+}
+export declare function createLocalStateStore(initialValue: any): any[];
+export declare function getGlobalState(key: string): any;
+export declare function setGlobalState(key: string, value: any): void;
+export declare function subscribeToGlobalState(key: string, callback: (value: any, key: string) => void): StateSubscription;
+export declare function useGlobalStateExternal<T>(key: string, initialValue?: T): [T, (newValue: T) => void];
+export declare class ExternalStateManager {
+    private static instance;
+    private constructor();
+    static getInstance(): ExternalStateManager;
+    get<T>(key: string): T;
+    set<T>(key: string, value: T): void;
+    useState<T>(key: string, initialValue?: T): [T, (newValue: T) => void];
+    subscribe(key: string, callback: (value: any, key: string) => void): StateSubscription;
+    getAll(): any;
+    has(key: string): boolean;
+    remove(key: string): void;
+    clear(): void;
+}
+export declare const stateManager: ExternalStateManager;
+export { globalStore };
+//# sourceMappingURL=stateManager.d.ts.map

package/dist/src/stateManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stateManager.d.ts","sourceRoot":"","sources":["../../src/stateManager.ts"],"names":[],"mappings":"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"}

package/dist/src/stateManager.js

@@ -0,0 +1,278 @@
+/* eslint-disable no-prototype-builtins */
+/* eslint-disable @typescript-eslint/no-this-alias */
+import { logger } from "./logger";
+const log = logger;
+class State {
+    events;
+    constructor() {
+        this.events = {};
+    }
+    subscribe(event, callback) {
+        const me = this;
+        if (!me.events.hasOwnProperty(event)) {
+            me.events[event] = [];
+        }
+        return me.events[event].push(callback);
+    }
+    publish(event, data = {}) {
+        const me = this;
+        if (!me.events.hasOwnProperty(event)) {
+            return [];
+        }
+        return me.events[event].map((callback) => callback(data));
+    }
+    unsubscribe(event, callbackIndex) {
+        if (this.events.hasOwnProperty(event) && this.events[event][callbackIndex - 1]) {
+            this.events[event].splice(callbackIndex - 1, 1);
+        }
+    }
+}
+export class Store {
+    mutations;
+    state;
+    status;
+    events;
+    stateSubscriptions = new Map();
+    constructor(params) {
+        const me = this;
+        if (params.hasOwnProperty("mutations")) {
+            this.mutations = params.mutations;
+        }
+        else {
+            this.mutations = {};
+        }
+        this.state = new Proxy(params.state || {}, {
+            set: function (state, key, value) {
+                const oldValue = state[key];
+                state[key] = value;
+                // Notify specific key subscribers
+                if (me.stateSubscriptions.has(key)) {
+                    me.stateSubscriptions.get(key).forEach((callback) => {
+                        callback(value, key);
+                    });
+                }
+                // Notify general state change listeners
+                me.events.publish("stateChange", { key, value, oldValue, state: me.state });
+                if (me.status !== "mutation") {
+                    log.warn(`You should use a mutation to set the value for state object ${key}.`);
+                }
+                me.status = "resting";
+                return true;
+            },
+        });
+        this.status = "resting";
+        this.events = new State();
+    }
+    getStateObject() {
+        return this.state;
+    }
+    getStateValue(key) {
+        return this.state[key];
+    }
+    setStateValue(key, value) {
+        this.status = "mutation";
+        this.state[key] = value;
+    }
+    subscribeToKey(key, callback) {
+        if (!this.stateSubscriptions.has(key)) {
+            this.stateSubscriptions.set(key, new Set());
+        }
+        this.stateSubscriptions.get(key).add(callback);
+        return {
+            unsubscribe: () => {
+                const subscribers = this.stateSubscriptions.get(key);
+                if (subscribers) {
+                    subscribers.delete(callback);
+                    if (subscribers.size === 0) {
+                        this.stateSubscriptions.delete(key);
+                    }
+                }
+            },
+        };
+    }
+    mutateStore(mutationKey, payload) {
+        const me = this;
+        if (typeof me.mutations[mutationKey] !== "function") {
+            log.warn(`Mutation with identifier ${mutationKey} does not exist`);
+            return false;
+        }
+        me.status = "mutation";
+        const newState = me.mutations[mutationKey](me.state, payload);
+        me.state = Object.assign(me.state, newState);
+        return true;
+    }
+}
+// Global store instance
+const globalStore = new Store({});
+// Component-level state management
+export class ComponentStateManager {
+    localState = new Map();
+    stateSubscriptions = new Map();
+    onStateChange;
+    stateProxy = null;
+    constructor(_, onStateChange) {
+        this.onStateChange = onStateChange;
+        this.createStateProxy();
+    }
+    createStateProxy() {
+        this.stateProxy = new Proxy({}, {
+            get: (_, key) => {
+                return this.localState.get(key);
+            },
+            set: (_, key, value) => {
+                const oldValue = this.localState.get(key);
+                if (oldValue !== value) {
+                    this.localState.set(key, value);
+                    this.onStateChange(key, value, true);
+                }
+                return true;
+            },
+            has: (_, key) => {
+                return this.localState.has(key);
+            },
+            ownKeys: (_) => {
+                return Array.from(this.localState.keys());
+            },
+            getOwnPropertyDescriptor: (_, key) => {
+                if (this.localState.has(key)) {
+                    return {
+                        enumerable: true,
+                        configurable: true,
+                        value: this.localState.get(key),
+                    };
+                }
+                return undefined;
+            },
+        });
+    }
+    getStateProxy() {
+        return this.stateProxy;
+    }
+    defineState(initialState) {
+        Object.entries(initialState).forEach(([key, value]) => {
+            if (!this.localState.has(key)) {
+                this.localState.set(key, value);
+                // Trigger initial state change to sync with component properties
+                this.onStateChange(key, value, true);
+            }
+        });
+    }
+    // Local state management
+    useState(key, initialValue) {
+        // Initialize if not exists
+        if (!this.localState.has(key)) {
+            this.localState.set(key, initialValue);
+        }
+        const currentValue = this.localState.get(key);
+        const setter = (newValue) => {
+            const oldValue = this.localState.get(key);
+            if (oldValue !== newValue) {
+                this.localState.set(key, newValue);
+                this.onStateChange(key, newValue, true);
+            }
+        };
+        return [currentValue, setter];
+    }
+    // Global state management
+    useGlobalState(key, initialValue) {
+        // Initialize global state if provided and doesn't exist
+        if (initialValue !== undefined && globalStore.getStateValue(key) === undefined) {
+            globalStore.setStateValue(key, initialValue);
+        }
+        const currentValue = globalStore.getStateValue(key);
+        // Subscribe to global state changes if not already subscribed
+        if (!this.stateSubscriptions.has(key)) {
+            const subscription = globalStore.subscribeToKey(key, (value) => {
+                this.onStateChange(key, value, false);
+            });
+            this.stateSubscriptions.set(key, subscription);
+        }
+        const setter = (newValue) => {
+            globalStore.setStateValue(key, newValue);
+        };
+        return [currentValue, setter];
+    }
+    getLocalState(key) {
+        return this.localState.get(key);
+    }
+    destroy() {
+        // Clean up all global state subscriptions
+        this.stateSubscriptions.forEach((subscription) => {
+            subscription.unsubscribe();
+        });
+        this.stateSubscriptions.clear();
+        this.localState.clear();
+    }
+}
+export function createLocalStateStore(initialValue) {
+    const id = crypto.randomUUID();
+    const setter = (newValue) => {
+        globalStore.setStateValue(id, newValue);
+    };
+    if (initialValue !== null) {
+        globalStore.setStateValue(id, initialValue);
+    }
+    return [globalStore.getStateValue(id), setter];
+}
+// External State Management Utilities
+export function getGlobalState(key) {
+    return globalStore.getStateValue(key);
+}
+export function setGlobalState(key, value) {
+    globalStore.setStateValue(key, value);
+}
+export function subscribeToGlobalState(key, callback) {
+    return globalStore.subscribeToKey(key, callback);
+}
+export function useGlobalStateExternal(key, initialValue) {
+    // Initialize if provided and doesn't exist
+    if (initialValue !== undefined && globalStore.getStateValue(key) === undefined) {
+        globalStore.setStateValue(key, initialValue);
+    }
+    const currentValue = globalStore.getStateValue(key);
+    const setter = (newValue) => {
+        globalStore.setStateValue(key, newValue);
+    };
+    return [currentValue, setter];
+}
+// State Manager Singleton for external access
+export class ExternalStateManager {
+    static instance;
+    constructor() { }
+    static getInstance() {
+        if (!ExternalStateManager.instance) {
+            ExternalStateManager.instance = new ExternalStateManager();
+        }
+        return ExternalStateManager.instance;
+    }
+    get(key) {
+        return globalStore.getStateValue(key);
+    }
+    set(key, value) {
+        globalStore.setStateValue(key, value);
+    }
+    useState(key, initialValue) {
+        return useGlobalStateExternal(key, initialValue);
+    }
+    subscribe(key, callback) {
+        return globalStore.subscribeToKey(key, callback);
+    }
+    getAll() {
+        return globalStore.getStateObject();
+    }
+    has(key) {
+        return globalStore.getStateValue(key) !== undefined;
+    }
+    remove(key) {
+        globalStore.setStateValue(key, undefined);
+    }
+    clear() {
+        const stateObj = globalStore.getStateObject();
+        Object.keys(stateObj).forEach((key) => {
+            globalStore.setStateValue(key, undefined);
+        });
+    }
+}
+// Convenience instance for immediate use
+export const stateManager = ExternalStateManager.getInstance();
+export { globalStore };

package/dist/src/types.d.ts

@@ -0,0 +1,32 @@
+import { EventBus } from "./appBuilder";
+import type { EventOrchestrator } from "./eventBus";
+export interface EventBusRecord {
+    id: string;
+    eventBus: EventBus;
+}
+export interface EventListenerRecord {
+    eventName: string;
+    remove: () => void;
+}
+export interface PageProps {
+    id: string;
+    orchestrator: EventOrchestrator;
+    bubbleEvents: boolean;
+}
+export interface ViewProps {
+    id: string;
+    orchestrator: EventOrchestrator;
+    bubbleEvents: boolean;
+}
+export interface ComponentProps {
+    id: string;
+    orchestrator: EventOrchestrator;
+    bubbleEvents: boolean;
+}
+export interface RenderOptions {
+    fade?: {
+        enabled: boolean;
+        duration?: number;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAC;AACxC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AACpD,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,QAAQ,CAAC;CACpB;AACD,MAAM,WAAW,mBAAmB;IAClC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,IAAI,CAAC;CACpB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,iBAAiB,CAAC;IAChC,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,iBAAiB,CAAC;IAChC,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,YAAY,EAAE,iBAAiB,CAAC;IAChC,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,CAAC,EAAE;QACL,OAAO,EAAE,OAAO,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;CACH"}

package/dist/src/types.js

@@ -0,0 +1 @@
+export {};