@coherent.js/core 1.0.0-beta.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Thomas Drouvin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,130 @@
+# @coherent.js/core
+
+[![npm version](https://img.shields.io/npm/v/@coherent.js/core.svg)](https://www.npmjs.com/package/@coherent.js/core)
+[![license: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](../../LICENSE)
+[![Node >= 20](https://img.shields.io/badge/node-%3E%3D20-brightgreen)](https://nodejs.org)
+
+Core runtime for Coherent.js — an object-based SSR framework focused on performance, streaming, and simplicity.
+
+- ESM-only, Node 20+
+- Pure object rendering to HTML
+- Optional CSS-like scoping for component encapsulation
+- Component system utilities, error boundaries, and performance hooks
+
+For a high-level overview and repository-wide instructions, see the root README: ../../README.md
+
+## Installation
+
+```bash
+pnpm add @coherent.js/core
+```
+
+Requirements:
+- Node.js >= 20
+- ESM module system
+
+## Quick start
+
+JavaScript (ESM):
+```js
+import { renderToString } from '@coherent.js/core';
+
+const html = await renderToString({
+  div: { class: 'greeting', text: 'Hello Coherent' }
+});
+
+console.log(html);
+```
+
+TypeScript:
+```ts
+import { renderToString } from '@coherent.js/core';
+
+async function main() {
+  const html = await renderToString({
+    div: { class: 'greeting', text: 'Hello Coherent (TS)' }
+  });
+  console.log(html);
+}
+
+main();
+```
+
+## Exports overview
+
+The package uses conditional exports; in development it may resolve to `src` while production resolves to `dist`.
+
+Key APIs (selected):
+- Rendering
+  - `renderToString(input, options?)`
+  - `render(input)` (alias of `renderToString`)
+  - `renderScopedComponent(input)` – applies scoped attributes and style processing
+  - `renderUnsafe(input)` – render without encapsulation
+- Component system (re-exported from internal modules)
+  - `createComponent`, `defineComponent`, `registerComponent`, `getComponent`, `getRegisteredComponents`
+  - State helpers: `withState`, `withStateUtils`, `createStateManager`
+  - Lazy: `lazy`, `isLazy`, `evaluateLazy`
+- Error boundaries (selected)
+  - `createErrorBoundary`, `withErrorBoundary`, `createAsyncErrorBoundary`
+  - `createGlobalErrorHandler`, `GlobalErrorHandler`
+
+Tip: When working in the monorepo website/dev flow, imports can resolve to `src` via `exports.development`.
+
+## Minimal component example
+
+```js
+import { createComponent, renderToString } from '@coherent.js/core';
+
+const Counter = createComponent(({ count = 0 }) => ({
+  div: {
+    class: 'counter',
+    children: [
+      { span: { text: `Count: ${count}` } }
+    ]
+  }
+}));
+
+const html = await renderToString(Counter({ count: 2 }));
+```
+
+TypeScript:
+```ts
+import { createComponent, renderToString } from '@coherent.js/core';
+
+type Props = { count?: number };
+
+const Counter = createComponent((props: Props) => ({
+  div: {
+    class: 'counter',
+    children: [ { span: { text: `Count: ${props.count ?? 0}` } } ]
+  }
+}));
+
+const html = await renderToString(Counter({ count: 2 }));
+```
+
+## Development
+
+Run tests for this package:
+```bash
+pnpm --filter @coherent.js/core run test
+```
+
+Watch mode:
+```bash
+pnpm --filter @coherent.js/core run test:watch
+```
+
+Type check:
+```bash
+pnpm --filter @coherent.js/core run typecheck
+```
+
+Build (from package dir or via workspace filter):
+```bash
+pnpm --filter @coherent.js/core run build
+```
+
+## License
+
+MIT © Coherent.js Team

package/dist/coherent.d.ts

@@ -0,0 +1,472 @@
+/**
+ * Convenience function to create a Coherent instance
+ */
+export function createCoherent(options?: {}): Coherent;
+/**
+ * Default instance for quick usage
+ */
+export const coherent: Coherent;
+export namespace server {
+    export { renderToString as render };
+    export { renderBatch };
+    export { renderToChunks as chunk };
+    export { createStreamingRenderer as stream };
+    export { performanceMonitor };
+}
+export namespace components {
+    export { createComponent };
+    export { withState };
+    export { withProps };
+    export { memo };
+    export { lazy };
+    export { validateComponent };
+    export { isCoherentObject };
+}
+export namespace utils {
+    export { extractProps };
+    export { hasChildren };
+    export { normalizeChildren };
+    export { deepClone };
+    export { escapeHtml };
+    export { isVoidElement };
+    export { formatAttributes };
+    export { minifyHtml };
+    export { mergeProps };
+    export { getNestedValue };
+    export { setNestedValue };
+    export { cssUtils };
+}
+export namespace performance {
+    export { performanceMonitor };
+    export { createCacheManager };
+    export { getCache };
+    export { resetCache };
+    export { getRenderingStats };
+}
+/**
+ * Version and build information
+ */
+export const VERSION: "1.0.0";
+export const BUILD_DATE: string;
+export const FEATURES: string;
+export default Coherent;
+/**
+ * Main Coherent Framework Class
+ * Provides a unified interface to all framework capabilities
+ */
+export class Coherent {
+    constructor(options?: {});
+    options: {
+        enableCache: boolean;
+        enableMonitoring: boolean;
+        enableDevTools: boolean;
+        cacheSize: any;
+        cacheTTL: any;
+        maxDepth: any;
+        minify: any;
+    };
+    cache: Object | undefined;
+    componentCache: import("./performance/component-cache.js").ComponentCache | undefined;
+    state: import("./state/reactive-state.js").ReactiveState;
+    router: import("./routing/router.js").Router | undefined;
+    errorHandler: any;
+    devTools: DevTools | undefined;
+    /**
+     * Primary render method - converts components to HTML
+     */
+    render(component: any, options?: {}): string;
+    /**
+     * Alias for render method (for clarity)
+     */
+    renderToString(component: any, options?: {}): string;
+    /**
+     * Batch rendering for multiple components
+     */
+    renderBatch(components: any, options?: {}): string[];
+    /**
+     * Streaming render for large components
+     */
+    stream(component: any, options?: {}): AsyncGenerator<any, void, unknown>;
+    /**
+     * Create a streaming renderer instance
+     */
+    createStreamingRenderer(options?: {}): import("./rendering/streaming-renderer.js").StreamingRenderer;
+    /**
+     * Component creation helpers
+     */
+    createComponent(definition: any): import("./components/component-system.js").Component;
+    withState(component: any, initialState: any): (WrappedComponent: any) => {
+        (props?: {}, globalState?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __hasState: boolean;
+        __stateContainer: {
+            initialized: boolean;
+            initialize(): void;
+            getState(): any;
+            setState(newState: any): boolean;
+            subscribe(listener: any): () => boolean;
+            unsubscribe(listener: any): boolean;
+            batch(batchFn: any): void;
+            destroy(): void;
+        };
+        __wrappedComponent: any;
+        cleanup(): void;
+    };
+    withProps(component: any, props: any): (WrappedComponent: any) => {
+        (originalProps?: {}, state?: {}, context?: {}): any;
+        displayName: any;
+        __isHOC: boolean;
+        __wrappedComponent: any;
+        __transform: any;
+    } | {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | {
+            maxSize: number;
+            cache: Map<any, any>;
+            onEvict: any;
+            get(key: any): any;
+            set(key: any, value: any): void;
+            has(key: any): boolean;
+            delete(key: any): boolean;
+            clear(): void;
+            get size(): number;
+        } | {
+            ttl: any;
+            cache: Map<any, any>;
+            timers: Map<any, any>;
+            onEvict: any;
+            get(key: any): any;
+            set(key: any, value: any): void;
+            has(key: any): boolean;
+            delete(key: any): boolean;
+            clear(): void;
+            get size(): number;
+        };
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    };
+    memo(component: any, areEqual: any): {
+        (...args: any[]): any;
+        cache: WeakMap<object, any> | {
+            maxSize: number;
+            cache: Map<any, any>;
+            onEvict: any;
+            get(key: any): any;
+            set(key: any, value: any): void;
+            has(key: any): boolean;
+            delete(key: any): boolean;
+            clear(): void;
+            get size(): number;
+        } | {
+            ttl: any;
+            cache: Map<any, any>;
+            timers: Map<any, any>;
+            onEvict: any;
+            get(key: any): any;
+            set(key: any, value: any): void;
+            has(key: any): boolean;
+            delete(key: any): boolean;
+            clear(): void;
+            get size(): number;
+        };
+        clear(): any;
+        delete(key: any): boolean;
+        has(key: any): boolean;
+        size(): any;
+        stats(): {
+            hits: number;
+            misses: number;
+            evictions: number;
+        };
+        resetStats(): void;
+        refresh(...args: any[]): any;
+    };
+    lazy(componentLoader: any): {
+        __isLazy: boolean;
+        __factory: any;
+        __options: {};
+        evaluate(...args: any[]): any;
+        invalidate(): /*elided*/ any;
+        isEvaluated(): boolean;
+        getCachedValue(): any;
+        map(transform: any): /*elided*/ any;
+        flatMap(transform: any): /*elided*/ any;
+        toString(): string;
+        toJSON(): any;
+    };
+    /**
+     * Component caching and memoization
+     */
+    memoize(component: any, keyGenerator: any, options?: {}): (...args: any[]) => any;
+    /**
+     * Update DOM with virtual DOM diffing
+     */
+    updateDOM(element: any, newComponent: any, componentId?: string, options?: {}): any;
+    /**
+     * Invalidate component cache by dependencies
+     */
+    invalidateCache(dependencies: any): number;
+    /**
+     * Reactive state management
+     */
+    setState(key: any, value: any): boolean;
+    getState(key: any): any;
+    watchState(key: any, callback: any, options: any): any;
+    createComputed(key: any, getter: any, options: any): {
+        _getter: any;
+        _cached: boolean;
+        _dirty: boolean;
+        get value(): any;
+        set value(newValue: any);
+        _compute(): void;
+        _value: any;
+        _invalidate(): void;
+        _observers: Set<any>;
+        _computedDependents: Set<any>;
+        _options: {
+            deep: boolean;
+            immediate: boolean;
+        };
+        watch(callback: any, options?: {}): () => void;
+        unwatch(observer: any): void;
+        unwatchAll(): void;
+    };
+    /**
+     * Event system
+     */
+    emit(eventName: any, data: any, target: any): {
+        name: any;
+        data: {};
+        target: null;
+        timestamp: number;
+        stopped: boolean;
+        preventDefault: boolean;
+    };
+    on(eventName: any, handler: any, componentId: any): () => void;
+    off(eventName: any, handler: any, componentId: any): void;
+    /**
+     * Router methods
+     */
+    navigate(location: any): Promise<any>;
+    getCurrentRoute(): any;
+    addRoutes(routes: any): void;
+    /**
+     * Form validation
+     */
+    createForm(schema: any, options: any): import("./forms/validation.js").FormValidator;
+    /**
+     * Component lifecycle
+     */
+    createComponentWithLifecycle(component: any, options: any): {
+        component: any;
+        lifecycle: import("./components/lifecycle.js").ComponentLifecycle;
+        mount: (container: any, props?: {}) => Promise<void>;
+        unmount: () => Promise<void>;
+        update: (newProps?: {}) => Promise<void>;
+    };
+    /**
+     * Error handling
+     */
+    handleError(error: any, context: any): any;
+    /**
+     * Performance and monitoring
+     */
+    getPerformanceStats(): {
+        cache: any;
+        componentCache: {
+            size: number;
+            maxSize: any;
+            hits: number;
+            misses: number;
+            hitRate: string | number;
+            evictions: number;
+            cleanups: number;
+            invalidations: number;
+            dependencies: number;
+            memoryUsage: number;
+        } | null;
+        monitor: any;
+        rendering: {
+            cache: any;
+            performance: any;
+        };
+    };
+    getPerformanceRecommendations(): {
+        type: string;
+        priority: string;
+        suggestion: string;
+        impact: string;
+        details: string;
+    }[];
+    /**
+     * Development and debugging tools
+     */
+    enableDevMode(): this;
+    disableDevMode(): this;
+    benchmark(component: any, iterations?: number): {
+        cache: any;
+        componentCache: {
+            size: number;
+            maxSize: any;
+            hits: number;
+            misses: number;
+            hitRate: string | number;
+            evictions: number;
+            cleanups: number;
+            invalidations: number;
+            dependencies: number;
+            memoryUsage: number;
+        } | null;
+        monitor: any;
+        rendering: {
+            cache: any;
+            performance: any;
+        };
+    };
+    /**
+     * Cache management
+     */
+    clearCache(): boolean;
+    getCacheStats(): any;
+    optimizeCache(): boolean;
+    /**
+     * Precompilation for static components
+     */
+    precompile(component: any, options?: {}): {
+        html: string;
+        isPrecompiled: boolean;
+        render: () => string;
+    };
+    /**
+     * Validation helpers
+     */
+    validate(component: any): {
+        valid: boolean;
+        error?: undefined;
+    } | {
+        valid: boolean;
+        error: any;
+    };
+    isCoherent(obj: any): boolean;
+    /**
+     * Utility methods
+     */
+    clone(obj: any): any;
+    merge(obj1: any, obj2: any): {};
+    extract(element: any): {};
+    normalize(children: any): any[];
+    escape(text: any): any;
+    /**
+     * Framework information
+     */
+    getVersion(): string;
+    getInfo(): {
+        name: string;
+        version: string;
+        description: string;
+        features: string[];
+        stats: {
+            cache: any;
+            componentCache: {
+                size: number;
+                maxSize: any;
+                hits: number;
+                misses: number;
+                hitRate: string | number;
+                evictions: number;
+                cleanups: number;
+                invalidations: number;
+                dependencies: number;
+                memoryUsage: number;
+            } | null;
+            monitor: any;
+            rendering: {
+                cache: any;
+                performance: any;
+            };
+        };
+    };
+}
+import { renderToString } from './rendering/html-renderer.js';
+import { renderHTML } from './rendering/html-renderer.js';
+import { renderHTMLSync } from './rendering/html-renderer.js';
+import { render } from './rendering/html-renderer.js';
+import { renderBatch } from './rendering/html-renderer.js';
+import { renderToChunks } from './rendering/html-renderer.js';
+import { renderWithTiming } from './rendering/html-renderer.js';
+import { createStreamingRenderer } from './rendering/streaming-renderer.js';
+import { streamingUtils } from './rendering/streaming-renderer.js';
+import { renderToDOM } from './rendering/dom-renderer.js';
+import { updateDOM } from './rendering/dom-renderer.js';
+import { hydrate } from './client/hydration.js';
+import { makeHydratable } from './client/hydration.js';
+import { hydrateAll } from './client/hydration.js';
+import { hydrateBySelector } from './client/hydration.js';
+import { enableClientEvents } from './client/hydration.js';
+import { createComponent } from './components/component-system.js';
+import { withState } from './components/component-system.js';
+import { withProps } from './components/component-system.js';
+import { memo } from './components/component-system.js';
+import { lazy } from './components/component-system.js';
+import { validateComponent } from './core/object-utils.js';
+import { isCoherentObject } from './core/object-utils.js';
+import { extractProps } from './core/object-utils.js';
+import { hasChildren } from './core/object-utils.js';
+import { normalizeChildren } from './core/object-utils.js';
+import { deepClone } from './core/object-utils.js';
+import { escapeHtml } from './core/html-utils.js';
+import { isVoidElement } from './core/html-utils.js';
+import { formatAttributes } from './core/html-utils.js';
+import { minifyHtml } from './core/html-utils.js';
+import { createHtmlConfig } from './rendering/renderer-config.js';
+import { createStreamingConfig } from './rendering/renderer-config.js';
+import { createDomConfig } from './rendering/renderer-config.js';
+import { createDevConfig } from './rendering/renderer-config.js';
+import { createProdConfig } from './rendering/renderer-config.js';
+import { validateConfig } from './rendering/renderer-config.js';
+import { mergeConfigs } from './rendering/renderer-config.js';
+import { getConfigPreset } from './rendering/renderer-config.js';
+import { CONFIG_PRESETS } from './rendering/renderer-config.js';
+import { performanceMonitor } from './performance/monitor.js';
+import { createComponentCache } from './performance/component-cache.js';
+import { createCacheManager } from './performance/cache-manager.js';
+import { memoize } from './performance/component-cache.js';
+import { getCache } from './rendering/html-renderer.js';
+import { resetCache } from './rendering/html-renderer.js';
+import { getRenderingStats } from './rendering/html-renderer.js';
+import { createErrorHandler } from './utils/error-handler.js';
+import { globalErrorHandler } from './utils/error-handler.js';
+import { createReactiveState } from './state/reactive-state.js';
+import { observable } from './state/reactive-state.js';
+import { computed } from './state/reactive-state.js';
+import { stateUtils } from './state/reactive-state.js';
+import { createLifecycleHooks } from './components/lifecycle.js';
+import { eventSystem } from './components/lifecycle.js';
+import { componentUtils } from './components/lifecycle.js';
+import { withLifecycle } from './components/lifecycle.js';
+import { createRouter } from './routing/router.js';
+import { routeGuards } from './routing/router.js';
+import { routeComponents } from './routing/router.js';
+import { createForm } from './forms/validation.js';
+import { validationRules } from './forms/validation.js';
+import { binding } from './forms/validation.js';
+import { formComponents } from './forms/validation.js';
+import { createCSSManager } from './rendering/css-manager.js';
+import { defaultCSSManager } from './rendering/css-manager.js';
+import { cssUtils } from './rendering/css-manager.js';
+import { DevTools } from './dev/dev-tools.js';
+import { mergeProps } from './core/object-utils.js';
+import { getNestedValue } from './core/object-utils.js';
+import { setNestedValue } from './core/object-utils.js';
+export { renderToString, renderHTML, renderHTMLSync, render, renderBatch, renderToChunks, renderWithTiming, createStreamingRenderer, streamingUtils, renderToDOM, updateDOM, hydrate, makeHydratable, autoHydrate, hydrateAll, hydrateBySelector, enableClientEvents, createComponent, withState, withProps, memo, lazy, validateComponent, isCoherentObject, extractProps, hasChildren, normalizeChildren, deepClone, escapeHtml, isVoidElement, formatAttributes, minifyHtml, createHtmlConfig, createStreamingConfig, createDomConfig, createDevConfig, createProdConfig, validateConfig, mergeConfigs, getConfigPreset, CONFIG_PRESETS, performanceMonitor, createComponentCache, createCacheManager, memoize, getCache, resetCache, getRenderingStats, createErrorHandler, globalErrorHandler, createReactiveState, observable, computed, stateUtils, createLifecycleHooks, eventSystem, componentUtils, withLifecycle, createRouter, routeGuards, routeComponents, createForm, validationRules, binding, formComponents, createCSSManager, defaultCSSManager, cssUtils, DevTools };
+//# sourceMappingURL=coherent.d.ts.map

package/dist/coherent.d.ts.map

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