@blac/core 2.0.0-rc.0 → 2.0.0-rc.10

package/dist/logging/Logger.d.ts

@@ -0,0 +1,57 @@
+export declare enum LogLevel {
+    ERROR = 0,
+    WARN = 1,
+    INFO = 2,
+    DEBUG = 3
+}
+export interface LogEntry {
+    level: string;
+    context: string;
+    message: string;
+    data?: any;
+    timestamp: number;
+}
+export interface LogConfig {
+    enabled: boolean;
+    level: LogLevel;
+    output: (entry: LogEntry) => void;
+}
+/**
+ * Creates a logger instance with given configuration
+ *
+ * @param config - Logger configuration
+ * @returns Logger instance with debug, info, warn, error, and configure methods
+ *
+ * @example
+ * ```ts
+ * const logger = createLogger({
+ *   enabled: true,
+ *   level: LogLevel.DEBUG,
+ *   output: (entry) => console.log(JSON.stringify(entry))
+ * });
+ * logger.debug('MyComponent', 'Rendering', { props: { foo: 'bar' } });
+ * ```
+ */
+export declare function createLogger(config: LogConfig): {
+    debug: (context: string, message: string, data?: any) => void;
+    info: (context: string, message: string, data?: any) => void;
+    warn: (context: string, message: string, data?: any) => void;
+    error: (context: string, message: string, data?: any) => void;
+    configure: (opts: Partial<LogConfig>) => void;
+};
+export declare const debug: (context: string, message: string, data?: any) => void;
+export declare const info: (context: string, message: string, data?: any) => void;
+export declare const warn: (context: string, message: string, data?: any) => void;
+export declare const error: (context: string, message: string, data?: any) => void;
+/**
+ * Configuration function that recreates the default logger
+ *
+ * @param opts - Partial logger configuration
+ *
+ * @example
+ * ```ts
+ * configureLogger({ enabled: true, level: LogLevel.DEBUG });
+ * ```
+ */
+export declare function configureLogger(opts: Partial<LogConfig>): void;
+//# sourceMappingURL=Logger.d.ts.map

package/dist/plugin/BlacPlugin.d.ts

@@ -0,0 +1,46 @@
+import type { StateContainer } from '../core/StateContainer';
+import type { Vertex } from '../core/Vertex';
+import type { BaseEvent } from '../types/events';
+export interface InstanceMetadata {
+    id: string;
+    className: string;
+    isDisposed: boolean;
+    name: string;
+    lastStateChangeTimestamp: number;
+    state: any;
+    createdAt: number;
+    isIsolated: boolean;
+    callstack?: string;
+    previousState?: any;
+    currentState?: any;
+}
+export interface PluginContext {
+    getInstanceMetadata(instance: StateContainer<any>): InstanceMetadata;
+    getState<S>(instance: StateContainer<S>): S;
+    queryInstances<T extends StateContainer<any>>(typeClass: new (...args: any[]) => T): T[];
+    getAllTypes(): Array<new (...args: any[]) => StateContainer<any>>;
+    getStats(): {
+        registeredTypes: number;
+        totalInstances: number;
+        typeBreakdown: Record<string, number>;
+    };
+}
+export interface BlacPlugin {
+    readonly name: string;
+    readonly version: string;
+    onInstall?(context: PluginContext): void;
+    onUninstall?(): void;
+    onInstanceCreated?(instance: StateContainer<any>, context: PluginContext): void;
+    onStateChanged?<S>(instance: StateContainer<S>, previousState: S, currentState: S, callstack: string | undefined, context: PluginContext): void;
+    onEventAdded?<E extends BaseEvent>(vertex: Vertex<any, E>, event: E, context: PluginContext): void;
+    onInstanceDisposed?(instance: StateContainer<any>, context: PluginContext): void;
+}
+export interface BlacPluginWithInit extends BlacPlugin {
+    onInstall(context: PluginContext): void;
+}
+export interface PluginConfig {
+    enabled?: boolean;
+    environment?: 'development' | 'production' | 'test' | 'all';
+}
+export declare function hasInitHook(plugin: BlacPlugin): plugin is BlacPluginWithInit;
+//# sourceMappingURL=BlacPlugin.d.ts.map

package/dist/plugin/PluginManager.d.ts

@@ -0,0 +1,38 @@
+import type { StateContainerRegistry } from '../core/StateContainerRegistry';
+import type { BlacPlugin, PluginConfig } from './BlacPlugin';
+export declare class PluginManager {
+    private plugins;
+    private registry;
+    constructor(registry: StateContainerRegistry);
+    install(plugin: BlacPlugin, config?: PluginConfig): void;
+    uninstall(pluginName: string): void;
+    getPlugin(pluginName: string): BlacPlugin | undefined;
+    getAllPlugins(): BlacPlugin[];
+    hasPlugin(pluginName: string): boolean;
+    clear(): void;
+    /**
+     * Setup lifecycle hooks to notify plugins
+     */
+    private setupLifecycleHooks;
+    /**
+     * Notify all plugins of a lifecycle event
+     */
+    private notifyPlugins;
+    /**
+     * Create plugin context with safe API access
+     */
+    private createPluginContext;
+    /**
+     * Check if plugin should be enabled based on environment
+     */
+    private shouldEnablePlugin;
+    /**
+     * Get current environment
+     */
+    private getCurrentEnvironment;
+}
+/**
+ * Create a plugin manager instance
+ */
+export declare function createPluginManager(registry: StateContainerRegistry): PluginManager;
+//# sourceMappingURL=PluginManager.d.ts.map

package/dist/registry/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Registry module (deprecated)
+ *
+ * Registry functionality has been consolidated into StateContainer.
+ * Use StateContainer static methods instead:
+ *
+ * - StateContainer.register() - Register a type
+ * - StateContainer.getOrCreate() - Get or create instance
+ * - StateContainer.isRegistered() - Check if type is registered
+ * - StateContainer.hasInstance() - Check if instance exists
+ * - StateContainer.removeInstance() - Remove instance
+ * - StateContainer.getAll() - Get all instances of a type
+ * - StateContainer.clear() - Clear all instances of a type
+ * - StateContainer.clearAllInstances() - Clear all instances
+ * - StateContainer.unregister() - Unregister a type
+ * - StateContainer.getStats() - Get statistics
+ */
+export { type BlocConstructor } from '../types/utilities';
+export { type InstanceId, instanceId as createInstanceId, } from '../types/branded';
+//# sourceMappingURL=index.d.ts.map

package/dist/test-utils/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Test utilities and fixtures
+ */
+/**
+ * Create a test state object
+ */
+export declare function createTestState<T extends Record<string, unknown>>(overrides?: Partial<T>): T;
+/**
+ * Wait for a condition to be true
+ */
+export declare function waitFor(condition: () => boolean, timeout?: number, interval?: number): Promise<void>;
+/**
+ * Create a mock subscription notify function
+ */
+export declare function createMockNotify<T = unknown>(): {
+    fn: import("vitest").Mock<(state: T) => void>;
+    calls: T[];
+    callCount: () => number;
+    lastCall: () => T;
+    reset: () => void;
+};
+/**
+ * Memory usage tracker for tests
+ */
+export declare class MemoryTracker {
+    private baseline;
+    start(): void;
+    getUsage(): number;
+    getMB(): number;
+}
+/**
+ * Performance timer for benchmarking
+ */
+export declare class PerfTimer {
+    private start;
+    private marks;
+    begin(): void;
+    mark(label: string): void;
+    end(): number;
+    getMark(label: string): number | undefined;
+    getAllMarks(): Record<string, number>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/tracking/dependency-tracker.d.ts

@@ -0,0 +1,21 @@
+import { type ProxyTrackerState } from './proxy-tracker';
+export interface PathInfo {
+    segments: string[];
+    value: any;
+}
+export interface TrackerState<T> {
+    proxyTrackerState: ProxyTrackerState<T>;
+    previousRenderPaths: Set<string>;
+    currentRenderPaths: Set<string>;
+    pathCache: Map<string, PathInfo>;
+    lastCheckedState: T | null;
+    lastCheckedValues: Map<string, any>;
+}
+export declare function optimizeTrackedPaths(paths: Set<string>): Set<string>;
+export declare function createTrackerState<T>(): TrackerState<T>;
+export declare function startTracking<T>(tracker: TrackerState<T>): void;
+export declare function createProxy<T>(tracker: TrackerState<T>, state: T): T;
+export declare function captureTrackedPaths<T>(tracker: TrackerState<T>, state: T): void;
+export declare function hasChanges<T>(tracker: TrackerState<T>, state: T): boolean;
+export declare function hasTrackedData<T>(tracker: TrackerState<T>): boolean;
+//# sourceMappingURL=dependency-tracker.d.ts.map

package/dist/tracking/getter-tracker.d.ts

@@ -0,0 +1,31 @@
+import type { StateContainer } from '../core/StateContainer';
+export interface GetterTrackerState {
+    trackedValues: Map<string | symbol, unknown>;
+    currentlyAccessing: Set<string | symbol>;
+    trackedGetters: Set<string | symbol>;
+    isTracking: boolean;
+    renderCache: Map<string | symbol, unknown>;
+    cacheValid: boolean;
+    externalDependencies: Set<StateContainer<any>>;
+}
+interface GetterExecutionContext {
+    tracker: GetterTrackerState | null;
+    currentBloc: StateContainer<any> | null;
+    depth: number;
+    visitedBlocs: Set<StateContainer<any>>;
+}
+export declare function getGetterExecutionContext(): GetterExecutionContext;
+export declare function getDescriptor(obj: any, prop: string | symbol): PropertyDescriptor | undefined;
+export declare function isGetter(obj: any, prop: string | symbol): boolean;
+export declare function createGetterTracker(): GetterTrackerState;
+export declare function setActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc, tracker: GetterTrackerState): void;
+export declare function clearActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc): void;
+export declare function getActiveTracker<TBloc extends StateContainer<any>>(bloc: TBloc): GetterTrackerState | undefined;
+export declare function commitTrackedGetters(tracker: GetterTrackerState): void;
+export declare function createBlocProxy<TBloc extends StateContainer<any>>(bloc: TBloc): TBloc;
+export declare function hasGetterChanges<TBloc extends StateContainer<any>>(bloc: TBloc, tracker: GetterTrackerState | null): boolean;
+export declare function invalidateRenderCache(tracker: GetterTrackerState): void;
+export declare function clearExternalDependencies(tracker: GetterTrackerState): void;
+export declare function resetGetterTracker(tracker: GetterTrackerState): void;
+export {};
+//# sourceMappingURL=getter-tracker.d.ts.map

package/dist/tracking/index.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Dependency Tracking
+ *
+ * Framework-agnostic dependency tracking utilities for automatic reactivity.
+ * These utilities can be used by any framework integration (React, Vue, Angular, etc.)
+ * to track property accesses and detect changes.
+ *
+ * ## Usage
+ *
+ * ```typescript
+ * import {
+ *   createTrackerState,
+ *   startTracking,
+ *   createProxy,
+ *   captureTrackedPaths,
+ *   hasChanges
+ * } from '@blac/core';
+ *
+ * // Create tracker state
+ * const tracker = createTrackerState<MyState>();
+ *
+ * // During render:
+ * startTracking(tracker);
+ * const proxy = createProxy(tracker, state);
+ * // ... render with proxy ...
+ * captureTrackedPaths(tracker, state);
+ *
+ * // On state change:
+ * if (hasChanges(tracker, newState)) {
+ *   // Trigger re-render
+ * }
+ * ```
+ */
+export { type TrackerState, type PathInfo, createTrackerState, startTracking, createProxy, captureTrackedPaths, hasChanges, hasTrackedData, } from './dependency-tracker';
+export { type ProxyTrackerState, createProxyTrackerState, startProxyTracking, stopProxyTracking, createProxyInternal, createArrayProxy, createProxyForTarget, isProxyable, } from './proxy-tracker';
+export { parsePath, getValueAtPath, shallowEqual } from './path-utils';
+export { type GetterTrackerState, createGetterTracker, createBlocProxy, hasGetterChanges, isGetter, getDescriptor, setActiveTracker, clearActiveTracker, getActiveTracker, commitTrackedGetters, invalidateRenderCache, resetGetterTracker, clearExternalDependencies, getGetterExecutionContext, } from './getter-tracker';
+//# sourceMappingURL=index.d.ts.map

package/dist/tracking/path-utils.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Path utilities for dependency tracking
+ *
+ * Provides utilities for parsing property paths and extracting values
+ * from nested objects using path strings.
+ */
+/**
+ * Parse a property path string into an array of segments
+ *
+ * Handles both dot notation (a.b.c) and bracket notation (a[0].b)
+ *
+ * @example
+ * parsePath('user.name') // ['user', 'name']
+ * parsePath('items[0].name') // ['items', '0', 'name']
+ * parsePath('data.users[2].address.city') // ['data', 'users', '2', 'address', 'city']
+ */
+export declare function parsePath(path: string): string[];
+/**
+ * Get a value from an object using a path of segments
+ *
+ * @example
+ * const obj = { user: { name: 'Alice', age: 30 } }
+ * getValueAtPath(obj, ['user', 'name']) // 'Alice'
+ * getValueAtPath(obj, ['user', 'age']) // 30
+ * getValueAtPath(obj, ['user', 'missing']) // undefined
+ */
+export declare function getValueAtPath(obj: any, segments: string[]): any;
+/**
+ * Shallow equality comparison for arrays
+ *
+ * Compares two arrays element-by-element using Object.is
+ *
+ * @example
+ * shallowEqual([1, 2, 3], [1, 2, 3]) // true
+ * shallowEqual([1, 2, 3], [1, 2, 4]) // false
+ * shallowEqual([1, 2], [1, 2, 3]) // false
+ */
+export declare function shallowEqual(arr1: unknown[], arr2: unknown[]): boolean;
+//# sourceMappingURL=path-utils.d.ts.map

package/dist/tracking/proxy-tracker.d.ts

@@ -0,0 +1,88 @@
+/**
+ * Functional proxy tracker for automatic dependency tracking
+ *
+ * This module provides a functional approach to proxy-based dependency tracking.
+ * Unlike the class-based ProxyTracker, this uses a state object pattern that's
+ * easier to integrate with functional programming patterns and framework hooks.
+ */
+/**
+ * Check if a value can be proxied
+ *
+ * Returns true for plain objects and arrays only.
+ * Excludes built-in objects like Date, Map, Set, etc.
+ */
+export declare function isProxyable(value: unknown): value is object;
+/**
+ * State container for proxy tracking
+ */
+export interface ProxyTrackerState<T> {
+    /** Set of all tracked property paths */
+    trackedPaths: Set<string>;
+    /** Whether tracking is currently active */
+    isTracking: boolean;
+    /** Cache of created proxies to avoid duplicates */
+    proxyCache: WeakMap<object, any>;
+    /** Cache of bound functions to maintain referential equality */
+    boundFunctionsCache: WeakMap<Function, Function> | null;
+    /** Last state object that was proxied (for cache invalidation) */
+    lastProxiedState: T | null;
+    /** Last proxy created (for cache reuse) */
+    lastProxy: T | null;
+    /** Maximum depth for nested proxy creation */
+    maxDepth: number;
+}
+/**
+ * Create a new proxy tracker state
+ *
+ * @example
+ * const state = createProxyTrackerState<MyState>();
+ * startProxyTracking(state);
+ * const proxy = createProxyForTarget(state, myObject);
+ * // ... use proxy ...
+ * const paths = stopProxyTracking(state);
+ */
+export declare function createProxyTrackerState<T>(): ProxyTrackerState<T>;
+/**
+ * Start tracking property accesses
+ *
+ * Clears previous tracked paths and enables tracking mode.
+ */
+export declare function startProxyTracking<T>(state: ProxyTrackerState<T>): void;
+/**
+ * Stop tracking and return the tracked paths
+ *
+ * Returns a new Set containing all tracked paths.
+ */
+export declare function stopProxyTracking<T>(state: ProxyTrackerState<T>): Set<string>;
+/**
+ * Create a proxy for an array with property access tracking
+ *
+ * Tracks:
+ * - Array element access (arr[0])
+ * - Length access (arr.length)
+ * - Array method calls (arr.map, arr.filter, etc.)
+ */
+export declare function createArrayProxy<T, U>(state: ProxyTrackerState<T>, target: U[], path: string, depth?: number): U[];
+/**
+ * Create a proxy for an object with property access tracking
+ *
+ * This is the core proxy creation function that recursively creates proxies
+ * for nested objects and arrays.
+ *
+ * Tracks:
+ * - Property access (obj.prop)
+ * - Nested property access (obj.nested.prop)
+ * - 'in' operator usage ('prop' in obj)
+ * - Object.keys, Object.entries, etc.
+ */
+export declare function createProxyInternal<T>(state: ProxyTrackerState<T>, target: T, path?: string, depth?: number): T;
+/**
+ * Create a proxy for a target with caching
+ *
+ * If the target hasn't changed since the last call, returns the cached proxy.
+ * Otherwise, creates a new proxy and caches it.
+ *
+ * This is the main entry point for creating tracked proxies.
+ */
+export declare function createProxyForTarget<T>(state: ProxyTrackerState<T>, target: T): T;
+//# sourceMappingURL=proxy-tracker.d.ts.map

package/dist/types/branded.d.ts

@@ -0,0 +1,9 @@
+declare const brand: unique symbol;
+export type Brand<T, B> = T & {
+    [brand]: B;
+};
+export type BrandedId<B> = Brand<string, B>;
+export type InstanceId = Brand<string, 'InstanceId'>;
+export declare function instanceId(id: string): InstanceId;
+export {};
+//# sourceMappingURL=branded.d.ts.map

package/dist/types/events.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base event interface for type-safe event system
+ */
+/**
+ * Base event interface
+ * Used by Vertex for event-driven state management
+ */
+export interface BaseEvent {
+    readonly type: string;
+    readonly timestamp: number;
+    readonly source?: string;
+}
+//# sourceMappingURL=events.d.ts.map

package/dist/types/utilities.d.ts

@@ -0,0 +1,19 @@
+import type { StateContainer } from '../core/StateContainer';
+export type ExtractState<T> = T extends StateContainer<infer S, any> ? S : never;
+export type ExtractProps<T> = T extends StateContainer<any, infer P> ? P : undefined;
+export type ExtractConstructorArgs<T> = T extends new (...args: infer P) => any ? P : never[];
+export type BlocConstructor<TBloc extends StateContainer<any, any>> = (new (...args: any[]) => TBloc) & {
+    resolve(instanceKey?: string, ...args: any[]): TBloc;
+    get(instanceKey?: string): TBloc;
+    getSafe(instanceKey?: string): {
+        error: Error;
+        instance: null;
+    } | {
+        error: null;
+        instance: TBloc;
+    };
+    release(instanceKey?: string): void;
+    isolated?: boolean;
+    keepAlive?: boolean;
+};
+//# sourceMappingURL=utilities.d.ts.map

package/dist/utils/equality.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Deep equality check with circular reference handling
+ */
+export declare function deepEqual<T>(a: T, b: T, seen?: WeakMap<WeakKey, any>): boolean;
+/**
+ * Shallow equality check (more performant for simple cases)
+ */
+export declare function shallowEqual<T>(a: T, b: T): boolean;
+//# sourceMappingURL=equality.d.ts.map

package/dist/utils/idGenerator.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Centralized ID Generation
+ *
+ * Provides consistent, collision-resistant ID generation for all BlaC subsystems.
+ * Uses timestamp + counter + random suffix for uniqueness.
+ */
+/**
+ * Creates an ID generator with isolated counter state
+ *
+ * @param prefix - Prefix for generated IDs
+ * @returns Object with next(), nextSimple(), and reset() methods
+ *
+ * @example
+ * ```ts
+ * const generator = createIdGenerator('sub');
+ * const id1 = generator.next(); // "sub:1698765432100_1_a3k9d7f2q"
+ * const id2 = generator.next(); // "sub:1698765432101_2_b4n8e9g3r"
+ * ```
+ */
+export declare function createIdGenerator(prefix: string): {
+    next: () => string;
+    nextSimple: () => string;
+    reset: () => void;
+};
+/**
+ * Generate ID with timestamp, counter, and random suffix (tree-shakeable)
+ *
+ * Format: `${prefix}:${timestamp}_${counter}_${random}`
+ *
+ * @param prefix - Prefix for the ID (e.g., 'sub', 'consumer', 'stage')
+ * @returns Branded ID string
+ *
+ * @example
+ * ```ts
+ * const id = generateId('sub');
+ * // Returns: "sub:1698765432100_1_a3k9d7f2q"
+ * ```
+ */
+export declare function generateId(prefix: string): string;
+/**
+ * Generate simple ID with timestamp and random (no counter tracking)
+ *
+ * Format: `${prefix}:${timestamp}_${random}`
+ *
+ * @param prefix - Prefix for the ID
+ * @returns Branded ID string
+ *
+ * @example
+ * ```ts
+ * const id = generateSimpleId('CounterBloc');
+ * // Returns: "CounterBloc:1698765432100_a3k9d7f2q"
+ * ```
+ */
+export declare function generateSimpleId(prefix: string, affix?: string): string;
+/**
+ * Reset all counters for testing purposes
+ * @internal
+ */
+export declare function __resetIdCounters(): void;
+/**
+ * Generate a unique isolated instance key
+ * Uses base36 encoding for compact, URL-safe identifiers
+ *
+ * Format: "isolated-{9-char-random-string}"
+ * Example: "isolated-k7x2m9p4q"
+ *
+ * @returns A unique isolated instance key
+ */
+export declare function generateIsolatedKey(): string;
+/**
+ * Check if a key is an isolated instance key
+ * @param key - The instance key to check
+ * @returns true if the key is an isolated instance key
+ */
+export declare function isIsolatedKey(key: string): boolean;
+//# sourceMappingURL=idGenerator.d.ts.map

package/dist/utils/immutable.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Deep clone with circular reference handling
+ */
+export declare function cloneDeep<T>(obj: T, cloned?: WeakMap<WeakKey, any>): T;
+/**
+ * Deep freeze with circular reference handling
+ *
+ * Note: Currently disabled by default for proxy tracking compatibility.
+ * Proxies cannot intercept property access on frozen objects due to proxy invariants.
+ *
+ * @param obj - Object to freeze
+ * @param frozen - WeakSet for tracking circular references
+ * @param enabled - Whether to actually freeze (default: false for proxy compatibility)
+ */
+export declare function deepFreeze<T>(obj: T, frozen?: WeakSet<WeakKey>, enabled?: boolean): T;
+//# sourceMappingURL=immutable.d.ts.map

package/dist/utils/stack-trace.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Stack trace utilities for DevTools
+ */
+/**
+ * Capture and parse the current call stack
+ * Filters out internal BlaC framework calls to show only user code
+ */
+export declare function captureStackTrace(): string;
+/**
+ * Parse a stack trace string into structured data
+ */
+export interface StackFrame {
+    functionName: string;
+    fileName: string;
+    lineNumber: number | null;
+    columnNumber: number | null;
+}
+export declare function parseStackTrace(stack: string): StackFrame[];
+//# sourceMappingURL=stack-trace.d.ts.map

package/dist/utils/static-props.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Utility functions for accessing static properties on StateContainer classes
+ */
+/**
+ * Get a static property from a class constructor
+ * Type-safe helper that avoids (Type as any) casts
+ *
+ * @param Type - The class constructor
+ * @param propName - The property name to access
+ * @param defaultValue - Optional default value if property is undefined
+ * @returns The property value or default
+ */
+export declare function getStaticProp<T>(Type: new (...args: any[]) => any, propName: string, defaultValue?: T): T | undefined;
+/**
+ * Check if a class is marked as isolated
+ * Isolated classes create separate instances per component
+ */
+export declare function isIsolatedClass(Type: new (...args: any[]) => any): boolean;
+/**
+ * Check if a class is marked as keepAlive
+ * KeepAlive classes are never auto-disposed when ref count reaches 0
+ */
+export declare function isKeepAliveClass(Type: new (...args: any[]) => any): boolean;
+/**
+ * Check if a class should be excluded from DevTools
+ * Used to prevent infinite loops when DevTools tracks itself
+ */
+export declare function isExcludedFromDevTools(Type: new (...args: any[]) => any): boolean;
+//# sourceMappingURL=static-props.d.ts.map