@zcomponent/core 0.0.8 → 0.0.9

package/lib/contexts/cookieconsentcontext.js

@@ -1,4 +1,4 @@
-import { defineContextType } from '../context';
+import { Context } from '../context';
 import { Observable } from '../observable';
 export var Status;
 (function (Status) {
@@ -12,28 +12,24 @@ export var ConsentStatus;
     ConsentStatus["granted"] = "granted";
     ConsentStatus["rejected"] = "rejected";
 })(ConsentStatus || (ConsentStatus = {}));
-export const CookieConsentContext = defineContextType((ctx) => {
-    const status = new Observable(Status.unknown);
-    const functionalCookies = new Observable(ConsentStatus.unknown);
-    const performanceCookies = new Observable(ConsentStatus.unknown);
-    const marketingCookies = new Observable(ConsentStatus.unknown);
-    const showSettings = new Observable(undefined);
-    const performanceVendors = [];
-    const marketingVendors = [];
-    const registerPerformanceVendor = (v) => performanceVendors.push(v);
-    const registerMarketingVendor = (v) => marketingVendors.push(v);
-    return {
-        status,
-        functionalCookies,
-        performanceCookies,
-        marketingCookies,
-        performanceVendors,
-        marketingVendors,
-        registerPerformanceVendor,
-        registerMarketingVendor,
-        showSettings
-    };
-});
+export class CookieConsentContext extends Context {
+    constructor() {
+        super(...arguments);
+        this.status = new Observable(Status.unknown);
+        this.functionalCookies = new Observable(ConsentStatus.unknown);
+        this.performanceCookies = new Observable(ConsentStatus.unknown);
+        this.marketingCookies = new Observable(ConsentStatus.unknown);
+        this.showSettings = new Observable(undefined);
+        this.performanceVendors = [];
+        this.marketingVendors = [];
+    }
+    registerPerformanceVendor(v) {
+        this.performanceVendors.push(v);
+    }
+    registerMarketingVendor(v) {
+        this.marketingVendors.push(v);
+    }
+}
 export function useCookieConsentFunctional(mgr) {
     return mgr.get(CookieConsentContext).functionalCookies;
 }

package/lib/contexts/environmentcontext.d.ts

@@ -1,10 +1,9 @@
-import { ContextManager } from '../context';
+import { ContextManager, Context } from '../context';
 import { Observable } from '../observable';
-export interface EnvirontmentContext {
-    designTime: Observable<boolean>;
-    editTime: Observable<boolean>;
+export declare class EnvironmentContext extends Context {
+    designTime: Observable<boolean, never>;
+    editTime: Observable<boolean, never>;
 }
-export declare const EnvironmentContext: import("../context").ContextTypeWithDefault<EnvirontmentContext, []>;
 export declare function isDesignTime(ctx: ContextManager): boolean;
 export declare function isEditTime(ctx: ContextManager): boolean;
 export declare function isDevelopmentBuild(ctx: ContextManager): boolean;

package/lib/contexts/environmentcontext.js

@@ -1,11 +1,12 @@
-import { defineContextType } from '../context';
+import { Context } from '../context';
 import { Observable } from '../observable';
-export const EnvironmentContext = defineContextType(() => {
-    return {
-        designTime: new Observable(false),
-        editTime: new Observable(false)
-    };
-});
+export class EnvironmentContext extends Context {
+    constructor() {
+        super(...arguments);
+        this.designTime = new Observable(false);
+        this.editTime = new Observable(false);
+    }
+}
 export function isDesignTime(ctx) {
     return ctx.get(EnvironmentContext).designTime.value;
 }

package/lib/contexts/gamepadcontext.d.ts

@@ -0,0 +1,40 @@
+import { Context, ContextManager } from '../context';
+import { Event } from '../event';
+export declare enum GamepadAxis {
+    LeftStickHorizontal = "LeftStickHorizontal",
+    LeftStickVertical = "LeftStickVertical",
+    RightStickHorizontal = "RightStickHorizontal",
+    RightStickVertical = "RightStickVertical"
+}
+export declare enum GamepadButton {
+    South = "South",
+    East = "East",
+    West = "West",
+    North = "North",
+    ShoulderLeft = "ShoulderLeft",
+    ShoulderRight = "ShoulderRight",
+    TriggerLeft = "TriggerLeft",
+    TriggerRight = "TriggerRight",
+    Select = "Select",
+    Start = "Start",
+    StickLeft = "StickLeft",
+    StickRight = "StickRight",
+    DUp = "DUp",
+    DDown = "DDown",
+    DLeft = "DLeft",
+    DRight = "DRight",
+    Center = "Center"
+}
+export declare class GamepadContext extends Context {
+    onGamepadsChange: Event<[]>;
+    activeGamepads: Set<number>;
+    private _registeredGamepads;
+    constructor(contextManager: ContextManager);
+    private _update;
+    getGamepad(indx: number): Gamepad | null;
+    forGamepadsMatchingIndex(requestedIndex: number | undefined, fn: (gamepad: Gamepad) => void): void;
+    registerGamepad(indx: number, gamepad: Gamepad): void;
+    unregsiterGamepad(indx: number): void;
+    dispose(): never;
+}
+export declare function translateGamepadAxis(axis: GamepadAxis): number;

package/lib/contexts/gamepadcontext.js

@@ -0,0 +1,99 @@
+import { Context } from '../context';
+import { Event } from '../event';
+import { isDesignTime } from './environmentcontext';
+export var GamepadAxis;
+(function (GamepadAxis) {
+    GamepadAxis["LeftStickHorizontal"] = "LeftStickHorizontal";
+    GamepadAxis["LeftStickVertical"] = "LeftStickVertical";
+    GamepadAxis["RightStickHorizontal"] = "RightStickHorizontal";
+    GamepadAxis["RightStickVertical"] = "RightStickVertical";
+})(GamepadAxis || (GamepadAxis = {}));
+export var GamepadButton;
+(function (GamepadButton) {
+    GamepadButton["South"] = "South";
+    GamepadButton["East"] = "East";
+    GamepadButton["West"] = "West";
+    GamepadButton["North"] = "North";
+    GamepadButton["ShoulderLeft"] = "ShoulderLeft";
+    GamepadButton["ShoulderRight"] = "ShoulderRight";
+    GamepadButton["TriggerLeft"] = "TriggerLeft";
+    GamepadButton["TriggerRight"] = "TriggerRight";
+    GamepadButton["Select"] = "Select";
+    GamepadButton["Start"] = "Start";
+    GamepadButton["StickLeft"] = "StickLeft";
+    GamepadButton["StickRight"] = "StickRight";
+    GamepadButton["DUp"] = "DUp";
+    GamepadButton["DDown"] = "DDown";
+    GamepadButton["DLeft"] = "DLeft";
+    GamepadButton["DRight"] = "DRight";
+    GamepadButton["Center"] = "Center";
+})(GamepadButton || (GamepadButton = {}));
+export class GamepadContext extends Context {
+    constructor(contextManager) {
+        super(contextManager, {});
+        this.onGamepadsChange = new Event();
+        this.activeGamepads = new Set();
+        this._registeredGamepads = new Map();
+        this._update = () => {
+            const gamepads = navigator.getGamepads();
+            let changes = false;
+            for (let i = 0; i < gamepads.length; i++) {
+                if (gamepads[i] === null && this.activeGamepads.has(i)) {
+                    this.activeGamepads.delete(i);
+                    changes = true;
+                }
+                else if (gamepads[i] !== null && !this.activeGamepads.has(i)) {
+                    this.activeGamepads.add(i);
+                    changes = true;
+                }
+            }
+            if (changes)
+                this.onGamepadsChange.emit();
+        };
+        if (!isDesignTime(contextManager) && typeof navigator.getGamepads === 'function') {
+            window.addEventListener('gamepadconnected', this._update);
+            window.addEventListener('gamepaddisconnected', this._update);
+        }
+        this._update();
+    }
+    getGamepad(indx) {
+        return this._registeredGamepads.get(indx) ?? (navigator.getGamepads?.()?.[indx] || null);
+    }
+    forGamepadsMatchingIndex(requestedIndex, fn) {
+        for (const indx of this.activeGamepads) {
+            if (requestedIndex !== undefined && indx !== requestedIndex)
+                continue;
+            const gamepad = this.getGamepad(indx);
+            if (gamepad)
+                fn(gamepad);
+        }
+    }
+    registerGamepad(indx, gamepad) {
+        this._registeredGamepads.set(indx, gamepad);
+        if (gamepad !== null)
+            this.activeGamepads.add(indx);
+        this.onGamepadsChange.emit();
+    }
+    unregsiterGamepad(indx) {
+        this._registeredGamepads.delete(indx);
+        this.activeGamepads.delete(indx);
+        this.onGamepadsChange.emit();
+    }
+    dispose() {
+        window.removeEventListener('gamepadconnected', this._update);
+        window.removeEventListener('gamepaddisconnected', this._update);
+        return super.dispose();
+    }
+}
+export function translateGamepadAxis(axis) {
+    switch (axis) {
+        case GamepadAxis.LeftStickHorizontal:
+            return 0;
+        case GamepadAxis.LeftStickVertical:
+            return 1;
+        case GamepadAxis.RightStickHorizontal:
+            return 2;
+        case GamepadAxis.RightStickVertical:
+            return 3;
+    }
+}

package/lib/contexts/loadcontext.d.ts

@@ -1,16 +1,21 @@
-import { ContextManager } from '../context';
+import { ContextManager, Context } from '../context';
 import { Observable } from '../observable';
-export interface LoadContext {
-    isConstructed: Observable<boolean>;
-    isLoaded: Observable<boolean>;
-    isStarted: Observable<boolean>;
+export declare class LoadContext extends Context {
+    isConstructed: Observable<boolean, never>;
+    isLoaded: Observable<boolean, never>;
+    isStarted: Observable<boolean, never>;
+    progressPercent: Observable<number, never>;
+    private _startedResolved;
     started: Promise<void>;
-    progressPercent: Observable<number>;
-    registerLoadable: (p: Promise<any>) => void;
-    start: () => void;
-    startWhenLoaded: () => void;
+    private _loadables;
+    private _startWhenLoaded;
+    private _totalLoadables;
+    private _loadedCount;
+    start(): void;
+    private _update;
+    startWhenLoaded(): void;
+    registerLoadable(p: Promise<any>): void;
 }
-export declare const LoadContext: import("../context").ContextTypeWithDefault<LoadContext, []>;
 export declare function useIsLoaded(mgr: ContextManager): Observable<boolean, never>;
 export declare function isLoaded(mgr: ContextManager): boolean;
 export declare function useIsStarted(mgr: ContextManager): Observable<boolean, never>;

package/lib/contexts/loadcontext.js

@@ -1,64 +1,61 @@
-import { defineContextType } from '../context';
+import { Context } from '../context';
 import { Observable } from '../observable';
-export const LoadContext = defineContextType((ctx) => {
-    let totalLoadables = 0;
-    let loadedCount = 0;
-    const loadables = new Set();
-    const isConstructed = new Observable(false);
-    const isLoaded = new Observable(false);
-    const isStarted = new Observable(false);
-    const startWhenLoaded = new Observable(false);
-    const progressPercent = new Observable(0);
-    let startedResolve;
-    const started = new Promise(resolve => startedResolve = resolve);
-    const start = () => {
-        if (isStarted.value)
+export class LoadContext extends Context {
+    constructor() {
+        super(...arguments);
+        this.isConstructed = new Observable(false);
+        this.isLoaded = new Observable(false);
+        this.isStarted = new Observable(false);
+        this.progressPercent = new Observable(0);
+        this.started = new Promise(resolve => this._startedResolved = resolve);
+        this._loadables = new Set();
+        this._startWhenLoaded = false;
+        this._totalLoadables = 0;
+        this._loadedCount = 0;
+    }
+    start() {
+        if (this.isStarted.value)
             return;
-        isStarted.value = true;
-        startedResolve?.();
+        this.isStarted.value = true;
+        this._startedResolved?.();
         if (document.body)
-            document.body.classList.add("zcomponent-started");
-    };
-    const update = () => {
-        if (loadables.size > 0 && isLoaded.value === true) {
-            isLoaded.value = false;
-            totalLoadables = loadables.size;
-            loadedCount = 0;
+            document.body.classList.add('zcomponent-started');
+    }
+    _update() {
+        if (this._loadables.size > 0 && this.isLoaded.value === true) {
+            this.isLoaded.value = false;
+            this._totalLoadables = this._loadables.size;
+            this._loadedCount = 0;
         }
-        if (loadables.size === 0 && isLoaded.value === false) {
-            isLoaded.value = true;
+        if (this._loadables.size === 0 && this.isLoaded.value === false) {
+            this.isLoaded.value = true;
             if (document.body)
                 document.body.classList.add("zcomponent-loaded");
         }
-        progressPercent.value = isLoaded.value ? 100 : (100 * loadedCount / totalLoadables);
-        if (startWhenLoaded.value && isLoaded.value && !isStarted.value) {
-            start();
+        this.progressPercent.value = this.isLoaded.value ? 100 : (100 * this._loadedCount / this._totalLoadables);
+        if (this._startWhenLoaded && this.isLoaded.value && !this.isStarted.value) {
+            this.start();
         }
-    };
-    const registerLoadable = (p) => {
-        loadables.add(p);
-        totalLoadables++;
+    }
+    startWhenLoaded() {
+        this._startWhenLoaded = true;
+        this._update();
+    }
+    registerLoadable(p) {
+        if (this.disposed)
+            return;
+        this._loadables.add(p);
+        this._totalLoadables++;
         p.finally(() => {
-            loadedCount++;
-            loadables.delete(p);
-            update();
+            if (this.disposed)
+                return;
+            this._loadedCount++;
+            this._loadables.delete(p);
+            this._update();
         });
-        update();
-    };
-    return {
-        isConstructed,
-        isLoaded,
-        isStarted,
-        started,
-        progressPercent,
-        registerLoadable,
-        start,
-        startWhenLoaded: () => {
-            startWhenLoaded.value = true;
-            update();
-        }
-    };
-});
+        this._update();
+    }
+}
 export function useIsLoaded(mgr) {
     return mgr.get(LoadContext).isLoaded;
 }

package/lib/contexts/tagcontext.d.ts

@@ -1,14 +1,13 @@
 import { Component } from "../component";
-import { ContextManager } from "../context";
-export interface TagContext {
-    registerComponent(component: Component, tags: string[]): any;
-    unregisterComponent(component: Component): any;
+import { ContextManager, Context } from "../context";
+export declare class TagContext extends Context {
+    tagsByComponent: Map<Component<any, import("../component").ConstructorProps>, Set<string>>;
+    componentsByLocalTag: Map<string, Set<Component<any, import("../component").ConstructorProps>>>;
+    componentsByGlobalTag: Map<string, Set<Component<any, import("../component").ConstructorProps>>>;
+    registerComponent(component: Component, tags: string[]): void;
+    unregisterComponent(component: Component): void;
     getComponentsByTag(tag: string): Set<Component>;
     getComponentsByTags(tags: string[]): Set<Component>;
-    tagsByComponent: Map<Component, Set<string>>;
-    componentsByLocalTag: Map<string, Set<Component>>;
-    componentsByGlobalTag: Map<string, Set<Component>>;
 }
-export declare const TagContext: import("../context").ContextTypeWithDefault<TagContext, []>;
-export declare function getComponentsByTag(mgr: ContextManager, tag: string): Set<Component<import("../component").ConstructorProps, any>>;
-export declare function getComponentsByTags(mgr: ContextManager, tags: string[]): Set<Component<import("../component").ConstructorProps, any>>;
+export declare function getComponentsByTag(mgr: ContextManager, tag: string): Set<Component<any, import("../component").ConstructorProps>>;
+export declare function getComponentsByTags(mgr: ContextManager, tags: string[]): Set<Component<any, import("../component").ConstructorProps>>;

package/lib/contexts/tagcontext.js

@@ -1,62 +1,54 @@
-import { defineContextType } from "../context";
-export const TagContext = defineContextType(ctx => {
-    // We have to cast here to avoid a circular dependency
-    const upstream = ctx.getExisting(TagContext);
-    const tagsByComponent = new Map();
-    const componentsByLocalTag = new Map();
-    const componentsByGlobalTag = upstream?.componentsByGlobalTag ?? new Map();
-    console.log();
-    const registerComponent = (component, tags) => {
-        unregisterComponent(component);
+import { Context } from "../context";
+export class TagContext extends Context {
+    constructor() {
+        super(...arguments);
+        this.tagsByComponent = new Map();
+        this.componentsByLocalTag = new Map();
+        this.componentsByGlobalTag = new Map();
+    }
+    registerComponent(component, tags) {
+        this.unregisterComponent(component);
         for (const tag of tags) {
-            const map = tag.startsWith('global:') ? componentsByGlobalTag : componentsByLocalTag;
+            const map = tag.startsWith('global:') ? this.componentsByGlobalTag : this.componentsByLocalTag;
             const set = map.get(tag) ?? new Set();
             set.add(component);
             map.set(tag, set);
         }
-        tagsByComponent.set(component, new Set(tags));
-    };
-    const unregisterComponent = (component) => {
-        let tags = tagsByComponent.get(component);
+        this.tagsByComponent.set(component, new Set(tags));
+    }
+    ;
+    unregisterComponent(component) {
+        let tags = this.tagsByComponent.get(component);
         if (!tags)
             return;
         for (const tag of tags.values()) {
-            const map = tag.startsWith('global:') ? componentsByGlobalTag : componentsByLocalTag;
+            const map = tag.startsWith('global:') ? this.componentsByGlobalTag : this.componentsByLocalTag;
             const entry = map.get(tag);
             if (!entry)
                 continue;
             entry.delete(component);
         }
-        tagsByComponent.delete(component);
-    };
-    const getComponentsByTag = (tag) => {
-        return ((tag.startsWith('global:') ? componentsByGlobalTag : componentsByLocalTag).get(tag)) ?? new Set();
-    };
-    const getComponentsByTags = (tags) => {
+        this.tagsByComponent.delete(component);
+    }
+    getComponentsByTag(tag) {
+        return ((tag.startsWith('global:') ? this.componentsByGlobalTag : this.componentsByLocalTag).get(tag)) ?? new Set();
+    }
+    getComponentsByTags(tags) {
         if (tags.length === 0)
             return new Set();
         if (tags.length === 1)
-            return getComponentsByTag(tags[0]);
+            return this.getComponentsByTag(tags[0]);
         const ret = new Set();
         for (const tag of tags) {
-            const map = tag.startsWith('global:') ? componentsByGlobalTag : componentsByLocalTag;
+            const map = tag.startsWith('global:') ? this.componentsByGlobalTag : this.componentsByLocalTag;
             const entries = map.get(tag);
             if (!entries)
                 continue;
             entries.forEach(entry => ret.add(entry));
         }
         return ret;
-    };
-    return {
-        tagsByComponent,
-        componentsByLocalTag,
-        componentsByGlobalTag,
-        getComponentsByTag,
-        getComponentsByTags,
-        registerComponent,
-        unregisterComponent,
-    };
-});
+    }
+}
 export function getComponentsByTag(mgr, tag) {
     return mgr.get(TagContext).getComponentsByTag(tag);
 }

package/lib/contexts/usereventcontext.d.ts

@@ -1,12 +1,12 @@
-import { ContextManager } from '../context';
+import { ContextManager, Context } from '../context';
 import { Event as EventClass } from '../event';
 import { Observable } from '../observable';
-export interface UserEventContext {
+export declare class UserEventContext extends Context {
     onUserEvent: EventClass<[Event]>;
-    nextUserEvent: Observable<Promise<Event>>;
-    registerUserEvent: (evt: Event) => void;
+    private _resolveNextUserEvent;
+    nextUserEvent: Observable<Promise<Event>, never>;
+    registerUserEvent(evt: Event): void;
 }
-export declare const UserEventContext: import("../context").ContextTypeWithDefault<UserEventContext, []>;
 export declare function useOnUserEvent(mgr: ContextManager): EventClass<[Event]>;
 export declare function nextUserEvent(mgr: ContextManager): Promise<Event>;
 export declare function registerUserEvent(mgr: ContextManager, evt: Event): void;

package/lib/contexts/usereventcontext.js

@@ -1,26 +1,21 @@
-import { defineContextType } from '../context';
+import { Context } from '../context';
 import { Event as EventClass } from '../event';
 import { Observable } from '../observable';
-export const UserEventContext = defineContextType((ctx) => {
-    const onUserEvent = new EventClass();
-    let resolveNextUserEvent;
-    const nextUserEvent = new Observable(new Promise(resolve => {
-        resolveNextUserEvent = resolve;
-    }), undefined, false);
-    const registerUserEvent = (evt) => {
-        const currentResolve = resolveNextUserEvent;
-        nextUserEvent.value = new Promise(resolve => {
-            resolveNextUserEvent = resolve;
+export class UserEventContext extends Context {
+    constructor() {
+        super(...arguments);
+        this.onUserEvent = new EventClass();
+        this.nextUserEvent = new Observable(new Promise(resolve => this._resolveNextUserEvent = resolve));
+    }
+    registerUserEvent(evt) {
+        const currentResolve = this._resolveNextUserEvent;
+        this.nextUserEvent.value = new Promise(resolve => {
+            this._resolveNextUserEvent = resolve;
         });
         currentResolve(evt);
-        onUserEvent.emit(evt);
-    };
-    return {
-        onUserEvent,
-        nextUserEvent,
-        registerUserEvent
-    };
-});
+        this.onUserEvent.emit(evt);
+    }
+}
 export function useOnUserEvent(mgr) {
     return mgr.get(UserEventContext).onUserEvent;
 }

package/lib/index.d.ts

@@ -10,5 +10,6 @@ export * from './contexts/cookieconsentcontext';
 export * from './contexts/analyticscontext';
 export * from './contexts/usereventcontext';
 export * from './contexts/tagcontext';
+export * from './contexts/gamepadcontext';
 export * from './observable';
 export * from './contexts/environmentcontext';

package/lib/index.js

@@ -10,6 +10,7 @@ export * from './contexts/cookieconsentcontext';
 export * from './contexts/analyticscontext';
 export * from './contexts/usereventcontext';
 export * from './contexts/tagcontext';
+export * from './contexts/gamepadcontext';
 export * from './observable';
 export * from './contexts/environmentcontext';
 const link = document.createElement('link');

package/lib/interfaces.d.ts

@@ -2,25 +2,25 @@ import { Prop } from './types';
 export interface ID {
     id: string;
 }
-export declare type Child = ID;
-export declare type NodeByID = {
+export type Child = ID;
+export type NodeByID = {
     [id: string]: NodeData | undefined;
 };
-export declare type PropsByID = {
+export type PropsByID = {
     [id: string]: {
         [id: string]: any;
     } | undefined;
 };
-export declare type BehaviorByID = {
+export type BehaviorByID = {
     [id: string]: BehaviorData | undefined;
 };
-export declare type Props = {
+export type Props = {
     [id: string]: Prop;
 };
-export declare type Import = string;
-export declare type ParsedImport = [string, string];
-export declare type ElementType = Import;
-export declare type PropType = string;
+export type Import = string;
+export type ParsedImport = [string, string];
+export type ElementType = Import;
+export type PropType = string;
 export interface ZComponentData {
     id: string;
     nodes: NodeByID;