@emberkit/core 0.1.2-alpha.0

package/dist/signals/helpers/core.js

@@ -0,0 +1,96 @@
+import { DEFAULT_EQUALS } from '../types.js';
+export function createSignal(initialValue, options = {}) {
+    const { equals = DEFAULT_EQUALS } = options;
+    let value = initialValue;
+    function notify() {
+        void equals;
+    }
+    function getter() {
+        return value;
+    }
+    function setter(newValue) {
+        if (!equals(value, newValue)) {
+            value = newValue;
+            notify();
+        }
+    }
+    const signal = {
+        get value() {
+            return value;
+        },
+        set value(newValue) {
+            if (!equals(value, newValue)) {
+                value = newValue;
+                notify();
+            }
+        },
+        peek() {
+            return value;
+        },
+        [Symbol.iterator]() {
+            let index = 0;
+            const methods = [getter, setter];
+            return {
+                next: () => {
+                    if (index < methods.length) {
+                        return { value: methods[index++], done: false };
+                    }
+                    return { done: true };
+                },
+                [Symbol.iterator]() {
+                    return this;
+                },
+            };
+        },
+    };
+    // Make it array-like for tuple destructuring: [getter, setter]
+    signal[0] = getter;
+    signal[1] = setter;
+    signal.length = 2;
+    return signal;
+}
+export function createMemo(computation, _options) {
+    void _options;
+    let value;
+    let isStale = true;
+    return {
+        get value() {
+            if (isStale) {
+                value = computation();
+                isStale = false;
+            }
+            return value;
+        },
+        peek() {
+            if (isStale) {
+                return computation();
+            }
+            return value;
+        },
+    };
+}
+export function createEffect(callback) {
+    let cleanup;
+    function run() {
+        if (cleanup) {
+            const fn = cleanup;
+            cleanup = undefined;
+            fn();
+        }
+        cleanup = callback();
+    }
+    run();
+    return () => {
+        if (cleanup) {
+            const fn = cleanup;
+            cleanup = undefined;
+            fn();
+        }
+    };
+}
+export function batch(fn) {
+    return fn();
+}
+export function untrack(fn) {
+    return fn();
+}

package/dist/signals/helpers/utils.js

@@ -0,0 +1,22 @@
+export function isSignal(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    return 'value' in value && 'peek' in value;
+}
+export function isReadonlySignal(signal) {
+    return !('value' in signal && Object.getOwnPropertyDescriptor(signal, 'value')?.set);
+}
+export function getSignalValue(signal) {
+    return signal.value;
+}
+export function setSignalValue(signal, value) {
+    if ('value' in signal) {
+        const descriptor = Object.getOwnPropertyDescriptor(signal, 'value');
+        if (descriptor && descriptor.writable) {
+            signal.value = value;
+        }
+    }
+}
+export function readSignal(signal) {
+    return signal.value;
+}

package/dist/signals/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './helpers/core.js';
+export * from './helpers/utils.js';

package/dist/signals/types.js

@@ -0,0 +1 @@
+export const DEFAULT_EQUALS = (prev, next) => prev === next;

package/dist/ssg/index.js

@@ -0,0 +1,119 @@
+export class SSGBuilder {
+    config;
+    manifest;
+    constructor(config) {
+        this.config = {
+            outDir: config.outDir,
+            routes: config.routes,
+            prerender: config.prerender ?? true,
+            cacheControl: config.cacheControl ?? 'public, max-age=3600',
+        };
+        this.manifest = {
+            pages: new Map(),
+            errors: new Map(),
+            buildTime: 0,
+        };
+    }
+    async build(renderFn) {
+        const start = Date.now();
+        const pages = await Promise.allSettled(this.config.routes.map(async (route) => {
+            const html = await renderFn(route);
+            const page = {
+                path: route,
+                html,
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/html',
+                    'Cache-Control': this.config.cacheControl,
+                },
+            };
+            this.manifest.pages.set(route, html);
+            return page;
+        }));
+        for (let i = 0; i < pages.length; i++) {
+            const result = pages[i];
+            if (result.status === 'rejected') {
+                this.manifest.errors.set(this.config.routes[i], result.reason);
+            }
+        }
+        this.manifest.buildTime = Date.now() - start;
+        return this.manifest;
+    }
+    getManifest() {
+        return this.manifest;
+    }
+    getBuildStats() {
+        return {
+            pages: this.manifest.pages.size,
+            errors: this.manifest.errors.size,
+            time: this.manifest.buildTime,
+        };
+    }
+}
+export async function generateStaticPages(routes, renderFn, options = {}) {
+    const builder = new SSGBuilder({
+        outDir: options.outDir ?? './dist',
+        routes,
+        ...options,
+    });
+    return builder.build(renderFn);
+}
+export function createSSGManifest(pages) {
+    return {
+        pages: new Map(pages.map((p) => [p.path, p.html])),
+        errors: new Map(),
+        buildTime: 0,
+    };
+}
+export function serializeManifest(manifest) {
+    return JSON.stringify({
+        pages: Array.from(manifest.pages.entries()),
+        errors: Array.from(manifest.errors.entries()).map(([k, v]) => [k, v.message]),
+        buildTime: manifest.buildTime,
+    });
+}
+export function deserializeManifest(json) {
+    const data = JSON.parse(json);
+    return {
+        pages: new Map(data.pages),
+        errors: new Map(data.errors),
+        buildTime: data.buildTime,
+    };
+}
+export const STATIC_ROUTE_PATTERNS = [
+    '/',
+    '/about',
+    '/contact',
+    '/blog',
+    '/pricing',
+];
+export function isStaticRoute(path) {
+    return (!path.includes('[') &&
+        !path.includes(':') &&
+        !path.startsWith('/api/') &&
+        !path.includes('...'));
+}
+export async function crawlRoutes(startPath, shouldCrawl, getLinks) {
+    const visited = new Set();
+    const queue = [startPath];
+    while (queue.length > 0) {
+        const path = queue.shift();
+        if (visited.has(path) || !isStaticRoute(path)) {
+            continue;
+        }
+        visited.add(path);
+        if (await shouldCrawl(path)) {
+            const html = await fetch(path).then((r) => r.text()).catch(() => '');
+            const links = getLinks(html);
+            for (const link of links) {
+                if (!visited.has(link)) {
+                    queue.push(link);
+                }
+            }
+        }
+    }
+    return [...visited];
+}
+export function estimateBuildTime(pages) {
+    return pages * 50;
+}

package/dist/ssr/helpers/render-html.js

@@ -0,0 +1,55 @@
+import { renderToString } from '../../runtime/helpers/render.js';
+export function renderToHTMLString(element) {
+    if (!element)
+        return '';
+    if (typeof element === 'string')
+        return element;
+    if (typeof element === 'number')
+        return String(element);
+    if (typeof element === 'object' && element !== null && 'type' in element) {
+        return renderToString(element);
+    }
+    return '';
+}
+export function renderChildrenToHTML(children) {
+    return children.map((child) => renderToHTMLString(child)).join('');
+}
+export function createHtmlDocument(html, options = {}) {
+    const { title = '', lang = 'en', doctype = '<!DOCTYPE html>', baseUrl = '', headExtra = '' } = options;
+    const fullHtml = doctype + '\n' +
+        `<html${lang ? ` lang="${lang}"` : ''}>\n` +
+        '<head>\n' +
+        `<meta charset="utf-8">\n` +
+        `<meta name="viewport" content="width=device-width, initial-scale=1">\n` +
+        (title ? `<title>${escapeHtml(title)}</title>\n` : '') +
+        (baseUrl ? `<base href="${baseUrl}">\n` : '') +
+        (headExtra ? headExtra + '\n' : '') +
+        '</head>\n' +
+        `<body>\n${html}\n</body>\n` +
+        '</html>';
+    return fullHtml;
+}
+export function escapeHtml(text) {
+    return text
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#039;');
+}
+export function createMetaTags(meta) {
+    return Object.entries(meta)
+        .map(([name, content]) => `<meta name="${escapeHtml(name)}" content="${escapeHtml(content)}">`)
+        .join('\n');
+}
+export function createLinkTags(links) {
+    return Object.entries(links)
+        .map(([rel, href]) => `<link rel="${escapeHtml(rel)}" href="${escapeHtml(href)}">`)
+        .join('\n');
+}
+export function createScriptTags(scripts) {
+    return scripts.map((src) => `<script src="${escapeHtml(src)}"></script>`).join('\n');
+}
+export function createStyleTags(styles) {
+    return styles.map((href) => `<link rel="stylesheet" href="${escapeHtml(href)}">`).join('\n');
+}

package/dist/ssr/helpers/ssr.js

@@ -0,0 +1,90 @@
+import { renderToHTMLString, createHtmlDocument } from './render-html.js';
+import { drainHeadContent } from '../../meta/head-registry.js';
+import { getStatusText } from '../types.js';
+export function renderSSR(element, options = {}) {
+    const { doctype = '<!DOCTYPE html>', title, lang = 'en', baseUrl, headExtra } = options;
+    const html = renderToHTMLString(element);
+    const collectedHead = drainHeadContent();
+    const allHeadExtra = [headExtra, collectedHead].filter(Boolean).join('\n');
+    const docOptions = {};
+    if (title !== undefined)
+        docOptions.title = title;
+    if (lang !== undefined)
+        docOptions.lang = lang;
+    if (doctype !== undefined)
+        docOptions.doctype = doctype;
+    if (baseUrl !== undefined)
+        docOptions.baseUrl = baseUrl;
+    if (allHeadExtra)
+        docOptions.headExtra = allHeadExtra;
+    const fullHtml = createHtmlDocument(html, docOptions);
+    return {
+        html: fullHtml,
+        status: 200,
+        headers: new Headers({
+            'Content-Type': 'text/html',
+        }),
+    };
+}
+export function renderSSRWithError(element, error, options = {}) {
+    const status = error && 'error' in error ? error.error.status : 500;
+    const message = error && 'error' in error ? error.error.message : 'Internal Server Error';
+    const errorHtml = error ? `<div class="error"><h1>Error ${status}</h1><p>${message}</p></div>` : '';
+    const html = renderToHTMLString(element) + errorHtml;
+    const collectedHead = drainHeadContent();
+    const allHeadExtra = [options.headExtra, collectedHead].filter(Boolean).join('\n');
+    const fullHtml = createHtmlDocument(html, {
+        title: `Error ${status} - ${getStatusText(status)}`,
+        ...options,
+        ...(allHeadExtra ? { headExtra: allHeadExtra } : {}),
+    });
+    return {
+        html: fullHtml,
+        status,
+        headers: new Headers({
+            'Content-Type': 'text/html',
+        }),
+    };
+}
+export function renderSSRWithHeaders(element, headers, options = {}) {
+    const result = renderSSR(element, options);
+    for (const [key, value] of Object.entries(headers)) {
+        result.headers.set(key, value);
+    }
+    return result;
+}
+export function createStreamingRenderer() {
+    const chunks = [];
+    return {
+        write(html) {
+            chunks.push(html);
+        },
+        writeChunk(type, content) {
+            if (type === 'status') {
+                chunks.push(`<!--status:${content}-->`);
+            }
+            else if (type === 'error') {
+                chunks.push(`<!--error:${content}-->`);
+            }
+            else {
+                chunks.push(content);
+            }
+        },
+        end() {
+            return chunks.join('');
+        },
+        reset() {
+            chunks.length = 0;
+        },
+    };
+}
+export function injectScripts(html, scripts) {
+    if (scripts.length === 0)
+        return html;
+    const scriptTags = scripts.map((src) => `<script src="${src}"></script>`).join('');
+    const insertPoint = html.lastIndexOf('</body>');
+    if (insertPoint === -1) {
+        return html + '\n' + scriptTags;
+    }
+    return html.slice(0, insertPoint) + scriptTags + html.slice(insertPoint);
+}

package/dist/ssr/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './helpers/render-html.js';
+export * from './helpers/ssr.js';

package/dist/ssr/types.js

@@ -0,0 +1,24 @@
+export const DEFAULT_DOCTYPE = '<!DOCTYPE html>';
+export const DEFAULT_LANG = 'en';
+export const STATUS_CODES = {
+    200: 'OK',
+    201: 'Created',
+    204: 'No Content',
+    301: 'Moved Permanently',
+    302: 'Found',
+    304: 'Not Modified',
+    400: 'Bad Request',
+    401: 'Unauthorized',
+    403: 'Forbidden',
+    404: 'Not Found',
+    405: 'Method Not Allowed',
+    409: 'Conflict',
+    422: 'Unprocessable Entity',
+    429: 'Too Many Requests',
+    500: 'Internal Server Error',
+    502: 'Bad Gateway',
+    503: 'Service Unavailable',
+};
+export function getStatusText(status) {
+    return STATUS_CODES[status] ?? 'Unknown';
+}