@pwfabric/runtime 0.0.0-stage → 1.0.0-rc.1

package/dist/auth/types.d.ts

@@ -0,0 +1,117 @@
+/**
+ * Authentication Types
+ *
+ * Authentication system types
+ *
+ * @module @pwfabric/runtime/auth/types
+ */
+/**
+ * Authentication provider type
+ */
+export type AuthProviderType = 'msal' | 'oauth2' | 'api-key' | 'custom';
+/**
+ * Authentication state
+ */
+export type AuthState = 'unauthenticated' | 'authenticating' | 'authenticated' | 'error' | 'expired';
+/**
+ * User identity
+ */
+export interface UserIdentity {
+    readonly id: string;
+    readonly name?: string;
+    readonly email?: string;
+    readonly worldId?: string;
+    readonly roles?: readonly string[];
+    readonly claims?: Record<string, unknown>;
+}
+/**
+ * Authentication token
+ */
+export interface AuthToken {
+    readonly accessToken: string;
+    readonly refreshToken?: string;
+    readonly idToken?: string;
+    readonly expiresAt: number;
+    readonly scopes: readonly string[];
+}
+/**
+ * Authentication session
+ */
+export interface AuthSession {
+    readonly id: string;
+    readonly state: AuthState;
+    readonly user?: UserIdentity;
+    readonly token?: AuthToken;
+    readonly provider: AuthProviderType;
+    readonly createdAt: number;
+    readonly expiresAt?: number;
+}
+/**
+ * Base auth provider configuration
+ */
+export interface AuthProviderConfig {
+    readonly type: AuthProviderType;
+    readonly clientId?: string;
+    readonly authority?: string;
+    readonly scopes?: readonly string[];
+    readonly redirectUri?: string;
+}
+/**
+ * MSAL configuration
+ */
+export interface MsalConfig extends AuthProviderConfig {
+    readonly type: 'msal';
+    readonly clientId: string;
+    readonly authority: string;
+    readonly scopes: readonly string[];
+    readonly redirectUri: string;
+    readonly worldId?: string;
+}
+/**
+ * OAuth2 configuration
+ */
+export interface OAuth2Config extends AuthProviderConfig {
+    readonly type: 'oauth2';
+    readonly authorizationEndpoint: string;
+    readonly tokenEndpoint: string;
+    readonly clientId: string;
+    readonly scopes: readonly string[];
+    readonly redirectUri: string;
+}
+/**
+ * API Key configuration
+ */
+export interface ApiKeyConfig extends AuthProviderConfig {
+    readonly type: 'api-key';
+    readonly headerName: string;
+    readonly keyPrefix?: string;
+}
+/**
+ * Authentication result
+ */
+export type AuthResult = {
+    readonly success: true;
+    readonly session: AuthSession;
+} | {
+    readonly success: false;
+    readonly error: AuthError;
+};
+/**
+ * Token acquisition result
+ */
+export type TokenResult = {
+    readonly success: true;
+    readonly token: AuthToken;
+} | {
+    readonly success: false;
+    readonly error: AuthError;
+};
+/**
+ * Authentication error
+ */
+export interface AuthError {
+    readonly type: 'invalid_config' | 'network_error' | 'invalid_credentials' | 'token_expired' | 'insufficient_scope' | 'provider_error';
+    readonly message: string;
+    readonly code?: string;
+    readonly cause?: unknown;
+}

package/dist/auth/types.js

@@ -0,0 +1,9 @@
+/**
+ * Authentication Types
+ *
+ * Authentication system types
+ *
+ * @module @pwfabric/runtime/auth/types
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/auth/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../src/auth/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG","sourcesContent":["/**\n * Authentication Types\n *\n * Authentication system types\n *\n * @module @pwfabric/runtime/auth/types\n */\n\n// ============================================================\n// AUTH PROVIDER TYPES\n// ============================================================\n\n/**\n * Authentication provider type\n */\nexport type AuthProviderType = 'msal' | 'oauth2' | 'api-key' | 'custom'\n\n/**\n * Authentication state\n */\nexport type AuthState = 'unauthenticated' | 'authenticating' | 'authenticated' | 'error' | 'expired'\n\n/**\n * User identity\n */\nexport interface UserIdentity {\n  readonly id: string\n  readonly name?: string\n  readonly email?: string\n  readonly worldId?: string\n  readonly roles?: readonly string[]\n  readonly claims?: Record<string, unknown>\n}\n\n/**\n * Authentication token\n */\nexport interface AuthToken {\n  readonly accessToken: string\n  readonly refreshToken?: string\n  readonly idToken?: string\n  readonly expiresAt: number\n  readonly scopes: readonly string[]\n}\n\n/**\n * Authentication session\n */\nexport interface AuthSession {\n  readonly id: string\n  readonly state: AuthState\n  readonly user?: UserIdentity\n  readonly token?: AuthToken\n  readonly provider: AuthProviderType\n  readonly createdAt: number\n  readonly expiresAt?: number\n}\n\n// ============================================================\n// AUTH CONFIGURATION\n// ============================================================\n\n/**\n * Base auth provider configuration\n */\nexport interface AuthProviderConfig {\n  readonly type: AuthProviderType\n  readonly clientId?: string\n  readonly authority?: string\n  readonly scopes?: readonly string[]\n  readonly redirectUri?: string\n}\n\n/**\n * MSAL configuration\n */\nexport interface MsalConfig extends AuthProviderConfig {\n  readonly type: 'msal'\n  readonly clientId: string\n  readonly authority: string\n  readonly scopes: readonly string[]\n  readonly redirectUri: string\n  readonly worldId?: string\n}\n\n/**\n * OAuth2 configuration\n */\nexport interface OAuth2Config extends AuthProviderConfig {\n  readonly type: 'oauth2'\n  readonly authorizationEndpoint: string\n  readonly tokenEndpoint: string\n  readonly clientId: string\n  readonly scopes: readonly string[]\n  readonly redirectUri: string\n}\n\n/**\n * API Key configuration\n */\nexport interface ApiKeyConfig extends AuthProviderConfig {\n  readonly type: 'api-key'\n  readonly headerName: string\n  readonly keyPrefix?: string\n}\n\n// ============================================================\n// AUTH RESULT TYPES\n// ============================================================\n\n/**\n * Authentication result\n */\nexport type AuthResult =\n  | { readonly success: true; readonly session: AuthSession }\n  | { readonly success: false; readonly error: AuthError }\n\n/**\n * Token acquisition result\n */\nexport type TokenResult =\n  | { readonly success: true; readonly token: AuthToken }\n  | { readonly success: false; readonly error: AuthError }\n\n/**\n * Authentication error\n */\nexport interface AuthError {\n  readonly type:\n    | 'invalid_config'\n    | 'network_error'\n    | 'invalid_credentials'\n    | 'token_expired'\n    | 'insufficient_scope'\n    | 'provider_error'\n  readonly message: string\n  readonly code?: string\n  readonly cause?: unknown\n}\n\n"]}

package/dist/binding/collection.d.ts

@@ -0,0 +1,190 @@
+/**
+ * Collection Binding
+ *
+ * Reactive collection binding for arrays/lists in surfaces
+ *
+ * Provides:
+ * - Reactive array subscriptions
+ * - Filter, sort, map operations
+ * - Item change tracking (add, remove, update)
+ * - Derived/computed collections
+ *
+ * @module @pwfabric/runtime/binding/collection
+ */
+/**
+ * Types of changes that can occur to a collection
+ */
+export type CollectionChangeType = 'add' | 'remove' | 'update' | 'reset' | 'reorder';
+/**
+ * Event emitted when collection changes
+ */
+export interface CollectionChangeEvent<T> {
+    /** Type of change */
+    readonly type: CollectionChangeType;
+    /** Index where change occurred (-1 for reset/reorder) */
+    readonly index: number;
+    /** Item that was affected (undefined for reset) */
+    readonly item?: T | undefined;
+    /** Previous items (for reset) */
+    readonly previousItems?: readonly T[] | undefined;
+    /** Timestamp of the change */
+    readonly timestamp: number;
+}
+/**
+ * Listener for collection changes
+ */
+export type CollectionChangeListener<T> = (items: readonly T[], event: CollectionChangeEvent<T>) => void;
+/**
+ * Reactive collection binding interface
+ */
+export interface CollectionBinding<T> {
+    /** Current items in the collection */
+    readonly items: readonly T[];
+    /** Field used as unique key for items */
+    readonly keyField: string;
+    /** Number of items */
+    readonly length: number;
+    /**
+     * Subscribe to collection changes
+     * @returns Unsubscribe function
+     */
+    subscribe(listener: CollectionChangeListener<T>): () => void;
+    /**
+     * Create a filtered view of the collection
+     */
+    filter(predicate: (item: T, index: number) => boolean): CollectionBinding<T>;
+    /**
+     * Create a sorted view of the collection
+     */
+    sort(comparator: (a: T, b: T) => number): CollectionBinding<T>;
+    /**
+     * Create a mapped view of the collection
+     */
+    map<U>(mapper: (item: T, index: number) => U): CollectionBinding<U>;
+    /**
+     * Create a sliced view of the collection
+     */
+    slice(start?: number, end?: number): CollectionBinding<T>;
+    /**
+     * Get item by key value
+     */
+    getByKey(keyValue: unknown): T | undefined;
+    /**
+     * Get item at index
+     */
+    at(index: number): T | undefined;
+    /**
+     * Find first item matching predicate
+     */
+    find(predicate: (item: T, index: number) => boolean): T | undefined;
+    /**
+     * Find index of first item matching predicate
+     */
+    findIndex(predicate: (item: T, index: number) => boolean): number;
+    /**
+     * Check if any item matches predicate
+     */
+    some(predicate: (item: T, index: number) => boolean): boolean;
+    /**
+     * Check if all items match predicate
+     */
+    every(predicate: (item: T, index: number) => boolean): boolean;
+    /**
+     * Reduce collection to single value
+     */
+    reduce<U>(reducer: (acc: U, item: T, index: number) => U, initial: U): U;
+    /**
+     * Dispose of the collection and all subscriptions
+     */
+    dispose(): void;
+}
+/**
+ * Mutable collection binding interface
+ */
+export interface MutableCollectionBinding<T> extends CollectionBinding<T> {
+    /**
+     * Add item to collection
+     */
+    add(item: T): void;
+    /**
+     * Add multiple items to collection
+     */
+    addMany(items: readonly T[]): void;
+    /**
+     * Remove item by key value
+     */
+    remove(keyValue: unknown): boolean;
+    /**
+     * Remove item at index
+     */
+    removeAt(index: number): T | undefined;
+    /**
+     * Update item by key value
+     */
+    update(keyValue: unknown, updates: Partial<T>): boolean;
+    /**
+     * Replace item at index
+     */
+    replace(index: number, item: T): void;
+    /**
+     * Replace all items
+     */
+    reset(items: readonly T[]): void;
+    /**
+     * Clear all items
+     */
+    clear(): void;
+    /**
+     * Move item from one index to another
+     */
+    move(fromIndex: number, toIndex: number): void;
+}
+/**
+ * Reactive collection implementation with change tracking
+ */
+export declare class ReactiveCollection<T> implements MutableCollectionBinding<T> {
+    private _items;
+    private readonly _keyField;
+    private readonly listeners;
+    private disposed;
+    constructor(initialItems?: readonly T[], keyField?: string);
+    get items(): readonly T[];
+    get keyField(): string;
+    get length(): number;
+    subscribe(listener: CollectionChangeListener<T>): () => void;
+    filter(predicate: (item: T, index: number) => boolean): CollectionBinding<T>;
+    sort(comparator: (a: T, b: T) => number): CollectionBinding<T>;
+    map<U>(mapper: (item: T, index: number) => U): CollectionBinding<U>;
+    slice(start?: number, end?: number): CollectionBinding<T>;
+    getByKey(keyValue: unknown): T | undefined;
+    at(index: number): T | undefined;
+    find(predicate: (item: T, index: number) => boolean): T | undefined;
+    findIndex(predicate: (item: T, index: number) => boolean): number;
+    some(predicate: (item: T, index: number) => boolean): boolean;
+    every(predicate: (item: T, index: number) => boolean): boolean;
+    reduce<U>(reducer: (acc: U, item: T, index: number) => U, initial: U): U;
+    add(item: T): void;
+    addMany(items: readonly T[]): void;
+    remove(keyValue: unknown): boolean;
+    removeAt(index: number): T | undefined;
+    update(keyValue: unknown, updates: Partial<T>): boolean;
+    replace(index: number, item: T): void;
+    reset(items: readonly T[]): void;
+    clear(): void;
+    move(fromIndex: number, toIndex: number): void;
+    dispose(): void;
+    private getKeyValue;
+    private notify;
+}
+/**
+ * Create a reactive collection
+ */
+export declare function createCollection<T>(initialItems?: readonly T[], keyField?: string): MutableCollectionBinding<T>;
+/**
+ * Create a read-only collection from existing data
+ */
+export declare function createReadOnlyCollection<T>(items: readonly T[], keyField?: string): CollectionBinding<T>;
+/**
+ * Create a collection from an async iterable
+ */
+export declare function createCollectionFromAsync<T>(asyncIterable: AsyncIterable<T>, keyField?: string): Promise<MutableCollectionBinding<T>>;

package/dist/binding/collection.js

@@ -0,0 +1,358 @@
+/**
+ * Collection Binding
+ *
+ * Reactive collection binding for arrays/lists in surfaces
+ *
+ * Provides:
+ * - Reactive array subscriptions
+ * - Filter, sort, map operations
+ * - Item change tracking (add, remove, update)
+ * - Derived/computed collections
+ *
+ * @module @pwfabric/runtime/binding/collection
+ */
+// ============================================================
+// REACTIVE COLLECTION IMPLEMENTATION
+// ============================================================
+/**
+ * Reactive collection implementation with change tracking
+ */
+export class ReactiveCollection {
+    _items;
+    _keyField;
+    listeners = new Set();
+    disposed = false;
+    constructor(initialItems = [], keyField = 'id') {
+        this._items = [...initialItems];
+        this._keyField = keyField;
+    }
+    get items() {
+        return this._items;
+    }
+    get keyField() {
+        return this._keyField;
+    }
+    get length() {
+        return this._items.length;
+    }
+    subscribe(listener) {
+        if (this.disposed) {
+            throw new Error('Cannot subscribe to disposed collection');
+        }
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    filter(predicate) {
+        return new DerivedCollection(this, (items) => items.filter((item, index) => predicate(item, index)));
+    }
+    sort(comparator) {
+        return new DerivedCollection(this, (items) => [...items].sort(comparator));
+    }
+    map(mapper) {
+        return new DerivedCollection(this, (items) => items.map((item, index) => mapper(item, index)));
+    }
+    slice(start, end) {
+        return new DerivedCollection(this, (items) => items.slice(start, end));
+    }
+    getByKey(keyValue) {
+        return this._items.find((item) => this.getKeyValue(item) === keyValue);
+    }
+    at(index) {
+        if (index < 0) {
+            return this._items[this._items.length + index];
+        }
+        return this._items[index];
+    }
+    find(predicate) {
+        return this._items.find((item, index) => predicate(item, index));
+    }
+    findIndex(predicate) {
+        return this._items.findIndex((item, index) => predicate(item, index));
+    }
+    some(predicate) {
+        return this._items.some((item, index) => predicate(item, index));
+    }
+    every(predicate) {
+        return this._items.every((item, index) => predicate(item, index));
+    }
+    reduce(reducer, initial) {
+        return this._items.reduce((acc, item, index) => reducer(acc, item, index), initial);
+    }
+    add(item) {
+        if (this.disposed)
+            return;
+        const index = this._items.length;
+        this._items.push(item);
+        this.notify({ type: 'add', index, item, timestamp: Date.now() });
+    }
+    addMany(items) {
+        if (this.disposed || items.length === 0)
+            return;
+        const startIndex = this._items.length;
+        this._items.push(...items);
+        // Notify for each added item
+        for (let i = 0; i < items.length; i++) {
+            this.notify({
+                type: 'add',
+                index: startIndex + i,
+                item: items[i],
+                timestamp: Date.now(),
+            });
+        }
+    }
+    remove(keyValue) {
+        if (this.disposed)
+            return false;
+        const index = this._items.findIndex((item) => this.getKeyValue(item) === keyValue);
+        if (index === -1)
+            return false;
+        const [item] = this._items.splice(index, 1);
+        this.notify({ type: 'remove', index, item, timestamp: Date.now() });
+        return true;
+    }
+    removeAt(index) {
+        if (this.disposed)
+            return undefined;
+        if (index < 0 || index >= this._items.length)
+            return undefined;
+        const [item] = this._items.splice(index, 1);
+        this.notify({ type: 'remove', index, item, timestamp: Date.now() });
+        return item;
+    }
+    update(keyValue, updates) {
+        if (this.disposed)
+            return false;
+        const index = this._items.findIndex((item) => this.getKeyValue(item) === keyValue);
+        if (index === -1)
+            return false;
+        const existing = this._items[index];
+        if (existing === undefined)
+            return false;
+        const updated = { ...existing, ...updates };
+        this._items[index] = updated;
+        this.notify({ type: 'update', index, item: updated, timestamp: Date.now() });
+        return true;
+    }
+    replace(index, item) {
+        if (this.disposed)
+            return;
+        if (index < 0 || index >= this._items.length)
+            return;
+        this._items[index] = item;
+        this.notify({ type: 'update', index, item, timestamp: Date.now() });
+    }
+    reset(items) {
+        if (this.disposed)
+            return;
+        const previousItems = this._items;
+        this._items = [...items];
+        this.notify({
+            type: 'reset',
+            index: -1,
+            previousItems,
+            timestamp: Date.now(),
+        });
+    }
+    clear() {
+        this.reset([]);
+    }
+    move(fromIndex, toIndex) {
+        if (this.disposed)
+            return;
+        if (fromIndex < 0 || fromIndex >= this._items.length)
+            return;
+        if (toIndex < 0 || toIndex >= this._items.length)
+            return;
+        if (fromIndex === toIndex)
+            return;
+        const [item] = this._items.splice(fromIndex, 1);
+        if (item === undefined)
+            return;
+        this._items.splice(toIndex, 0, item);
+        this.notify({ type: 'reorder', index: toIndex, item, timestamp: Date.now() });
+    }
+    dispose() {
+        this.disposed = true;
+        this.listeners.clear();
+    }
+    getKeyValue(item) {
+        if (typeof item === 'object' && item !== null) {
+            return item[this._keyField];
+        }
+        return item;
+    }
+    notify(event) {
+        const items = this._items;
+        for (const listener of this.listeners) {
+            try {
+                listener(items, event);
+            }
+            catch {
+                // Swallow errors from listeners
+            }
+        }
+    }
+}
+// ============================================================
+// DERIVED COLLECTION IMPLEMENTATION
+// ============================================================
+/**
+ * Derived collection that transforms a source collection
+ */
+class DerivedCollection {
+    source;
+    transform;
+    listeners = new Set();
+    _items;
+    unsubscribe = null;
+    disposed = false;
+    constructor(source, transform) {
+        this.source = source;
+        this.transform = transform;
+        this._items = transform(source.items);
+        // Subscribe to source changes
+        this.unsubscribe = source.subscribe(() => {
+            this.update();
+        });
+    }
+    get items() {
+        return this._items;
+    }
+    get keyField() {
+        return this.source.keyField;
+    }
+    get length() {
+        return this._items.length;
+    }
+    subscribe(listener) {
+        if (this.disposed) {
+            throw new Error('Cannot subscribe to disposed collection');
+        }
+        this.listeners.add(listener);
+        return () => {
+            this.listeners.delete(listener);
+        };
+    }
+    filter(predicate) {
+        return new DerivedCollection(this, (items) => items.filter((item, index) => predicate(item, index)));
+    }
+    sort(comparator) {
+        return new DerivedCollection(this, (items) => [...items].sort(comparator));
+    }
+    map(mapper) {
+        return new DerivedCollection(this, (items) => items.map((item, index) => mapper(item, index)));
+    }
+    slice(start, end) {
+        return new DerivedCollection(this, (items) => items.slice(start, end));
+    }
+    getByKey(keyValue) {
+        // Note: For derived collections with map transforms, key lookup may not work as expected
+        return this._items.find((item) => {
+            if (typeof item === 'object' && item !== null) {
+                return item[this.keyField] === keyValue;
+            }
+            return item === keyValue;
+        });
+    }
+    at(index) {
+        if (index < 0) {
+            return this._items[this._items.length + index];
+        }
+        return this._items[index];
+    }
+    find(predicate) {
+        return this._items.find((item, index) => predicate(item, index));
+    }
+    findIndex(predicate) {
+        return this._items.findIndex((item, index) => predicate(item, index));
+    }
+    some(predicate) {
+        return this._items.some((item, index) => predicate(item, index));
+    }
+    every(predicate) {
+        return this._items.every((item, index) => predicate(item, index));
+    }
+    reduce(reducer, initial) {
+        return this._items.reduce((acc, item, index) => reducer(acc, item, index), initial);
+    }
+    dispose() {
+        this.disposed = true;
+        this.listeners.clear();
+        if (this.unsubscribe) {
+            this.unsubscribe();
+            this.unsubscribe = null;
+        }
+    }
+    update() {
+        const previousItems = this._items;
+        this._items = this.transform(this.source.items);
+        // Notify listeners
+        const event = {
+            type: 'reset',
+            index: -1,
+            previousItems,
+            timestamp: Date.now(),
+        };
+        for (const listener of this.listeners) {
+            try {
+                listener(this._items, event);
+            }
+            catch {
+                // Swallow errors from listeners
+            }
+        }
+    }
+}
+// ============================================================
+// FACTORY FUNCTIONS
+// ============================================================
+/**
+ * Create a reactive collection
+ */
+export function createCollection(initialItems, keyField) {
+    return new ReactiveCollection(initialItems, keyField);
+}
+/**
+ * Create a read-only collection from existing data
+ */
+export function createReadOnlyCollection(items, keyField = 'id') {
+    const collection = new ReactiveCollection(items, keyField);
+    // Return interface without mutation methods
+    return {
+        get items() {
+            return collection.items;
+        },
+        get keyField() {
+            return collection.keyField;
+        },
+        get length() {
+            return collection.length;
+        },
+        subscribe: (listener) => collection.subscribe(listener),
+        filter: (predicate) => collection.filter(predicate),
+        sort: (comparator) => collection.sort(comparator),
+        map: (mapper) => collection.map(mapper),
+        slice: (start, end) => collection.slice(start, end),
+        getByKey: (keyValue) => collection.getByKey(keyValue),
+        at: (index) => collection.at(index),
+        find: (predicate) => collection.find(predicate),
+        findIndex: (predicate) => collection.findIndex(predicate),
+        some: (predicate) => collection.some(predicate),
+        every: (predicate) => collection.every(predicate),
+        reduce: (reducer, initial) => collection.reduce(reducer, initial),
+        dispose: () => collection.dispose(),
+    };
+}
+/**
+ * Create a collection from an async iterable
+ */
+export async function createCollectionFromAsync(asyncIterable, keyField = 'id') {
+    const items = [];
+    for await (const item of asyncIterable) {
+        items.push(item);
+    }
+    return new ReactiveCollection(items, keyField);
+}
+//# sourceMappingURL=collection.js.map