@emberkit/core 0.1.2-alpha.0

package/dist/mdx/index.js

@@ -0,0 +1,156 @@
+import { parseMarkdown } from '../markdown/index.js';
+class MDXCompiler {
+    config;
+    components;
+    constructor(config = {}) {
+        this.config = config;
+        this.components = new Map(Object.entries(config.components ?? {}));
+    }
+    compile(source) {
+        const parsed = parseMarkdown(source, { gfm: this.config.gfm, breaks: this.config.breaks, tables: this.config.tables });
+        const { html, frontmatter } = parsed;
+        const componentCode = this.generateComponent(html);
+        return this.createComponent(componentCode, frontmatter);
+    }
+    generateComponent(html) {
+        const headings = this.extractHeadingIds(html);
+        const paragraphs = this.splitParagraphs(html);
+        let code = 'return (';
+        for (const p of paragraphs) {
+            if (p.startsWith('<h')) {
+                code += p;
+            }
+            else if (p.startsWith('<ul') || p.startsWith('<ol')) {
+                code += p;
+            }
+            else if (p.startsWith('<pre')) {
+                code += p;
+            }
+            else if (p.startsWith('<blockquote')) {
+                code += p;
+            }
+            else if (p.startsWith('<table')) {
+                code += p;
+            }
+            else {
+                code += `<p>${p}</p>`;
+            }
+        }
+        code += ')';
+        return code;
+    }
+    extractHeadingIds(html) {
+        const ids = [];
+        const regex = /id="([^"]+)"/g;
+        let match;
+        while ((match = regex.exec(html)) !== null) {
+            ids.push(match[1]);
+        }
+        return ids;
+    }
+    splitParagraphs(html) {
+        return html
+            .split(/\n\n+/)
+            .map((p) => p.trim())
+            .filter(Boolean);
+    }
+    createComponent(code, frontmatter) {
+        try {
+            const fn = new Function('createElement', code);
+            const component = (props) => {
+                const element = fn(createElementProxy);
+                return element;
+            };
+            if (frontmatter) {
+                component.frontmatter = frontmatter;
+            }
+            return component;
+        }
+        catch (error) {
+            console.error('MDX compilation error:', error);
+            return () => ({ type: 'div', props: { children: 'MDX Error' } });
+        }
+    }
+    registerComponent(name, component) {
+        this.components.set(name, component);
+    }
+    unregisterComponent(name) {
+        this.components.delete(name);
+    }
+    getComponent(name) {
+        return this.components.get(name);
+    }
+}
+const createElementProxy = {
+    createElement(tag, props, ...children) {
+        return {
+            type: tag,
+            props: {
+                ...props,
+                children: children.length === 1 ? children[0] : children,
+            },
+        };
+    },
+};
+export function createMDXCompiler(config) {
+    return new MDXCompiler(config);
+}
+export async function compileMDX(source, options) {
+    const compiler = createMDXCompiler(options);
+    return compiler.compile(source);
+}
+export function compileSync(source, options) {
+    const compiler = createMDXCompiler(options);
+    return compiler.compile(source);
+}
+export function useMDX(source, options) {
+    return compileSync(source, options);
+}
+export const DEFAULT_COMPONENTS = {
+    pre: (props) => ({ type: 'pre', props }),
+    code: (props) => {
+        const className = props.className;
+        const lang = className?.replace('language-', '') ?? '';
+        return {
+            type: 'code',
+            props: { ...props, className: lang ? `language-${lang}` : undefined },
+        };
+    },
+    h1: (props) => {
+        const children = props.children;
+        const id = children?.toLowerCase().replace(/\s+/g, '-');
+        return { type: 'h1', props: { ...props, id } };
+    },
+    h2: (props) => {
+        const children = props.children;
+        const id = children?.toLowerCase().replace(/\s+/g, '-');
+        return { type: 'h2', props: { ...props, id } };
+    },
+    a: (props) => {
+        const href = props.href;
+        if (href?.startsWith('/')) {
+            return { type: 'a', props: { ...props, 'data-link': '' } };
+        }
+        return { type: 'a', props: { ...props, target: '_blank', rel: 'noopener noreferrer' } };
+    },
+    img: (props) => ({
+        type: 'img',
+        props: { ...props, loading: 'lazy', decoding: 'async' },
+    }),
+    table: (props) => {
+        return {
+            type: 'div',
+            props: {
+                className: 'table-wrapper',
+                children: [{
+                        type: 'table',
+                        props: { children: [props.children] }
+                    }]
+            },
+        };
+    },
+};
+export function mergeComponents(base, override) {
+    return { ...base, ...override };
+}
+export { parseMarkdown };

package/dist/mdx/loader.js

@@ -0,0 +1,6 @@
+import { compileMDX } from './index.js';
+export async function loadMDX(path, options) {
+    const fs = await import('node:fs');
+    const source = fs.readFileSync(path, 'utf-8');
+    return compileMDX(source, options);
+}

package/dist/meta/head-registry.js

@@ -0,0 +1,15 @@
+let headBuffer = [];
+export function registerHeadContent(html) {
+    headBuffer.push(html);
+}
+export function drainHeadContent() {
+    const content = headBuffer.join('\n');
+    headBuffer = [];
+    return content;
+}
+export function peekHeadContent() {
+    return headBuffer.join('\n');
+}
+export function clearHeadContent() {
+    headBuffer = [];
+}

package/dist/meta/head.js

@@ -0,0 +1,100 @@
+import { renderToString } from '../runtime/helpers/render.js';
+import { registerHeadContent } from './head-registry.js';
+import { escapeHtml } from '../ssr/helpers/render-html.js';
+const MANAGED_ATTR = 'data-ek-head';
+function buildShorthandTags(props) {
+    const tags = [];
+    if (props.title) {
+        tags.push(`<title ${MANAGED_ATTR}>${escapeHtml(props.title)}</title>`);
+        tags.push(`<meta ${MANAGED_ATTR} name="title" content="${escapeHtml(props.title)}">`);
+    }
+    if (props.description) {
+        tags.push(`<meta ${MANAGED_ATTR} name="description" content="${escapeHtml(props.description)}">`);
+    }
+    if (props.keywords?.length) {
+        tags.push(`<meta ${MANAGED_ATTR} name="keywords" content="${escapeHtml(props.keywords.join(', '))}">`);
+    }
+    if (props.author) {
+        tags.push(`<meta ${MANAGED_ATTR} name="author" content="${escapeHtml(props.author)}">`);
+    }
+    if (props.robots) {
+        tags.push(`<meta ${MANAGED_ATTR} name="robots" content="${escapeHtml(props.robots)}">`);
+    }
+    if (props.canonical) {
+        tags.push(`<link ${MANAGED_ATTR} rel="canonical" href="${escapeHtml(props.canonical)}">`);
+    }
+    if (props.og) {
+        const og = props.og;
+        if (og.type)
+            tags.push(`<meta ${MANAGED_ATTR} property="og:type" content="${escapeHtml(og.type)}">`);
+        if (og.title)
+            tags.push(`<meta ${MANAGED_ATTR} property="og:title" content="${escapeHtml(og.title)}">`);
+        if (og.description)
+            tags.push(`<meta ${MANAGED_ATTR} property="og:description" content="${escapeHtml(og.description)}">`);
+        if (og.url)
+            tags.push(`<meta ${MANAGED_ATTR} property="og:url" content="${escapeHtml(og.url)}">`);
+        if (og.image)
+            tags.push(`<meta ${MANAGED_ATTR} property="og:image" content="${escapeHtml(og.image)}">`);
+        if (og.locale)
+            tags.push(`<meta ${MANAGED_ATTR} property="og:locale" content="${escapeHtml(og.locale)}">`);
+        if (og.siteName)
+            tags.push(`<meta ${MANAGED_ATTR} property="og:site_name" content="${escapeHtml(og.siteName)}">`);
+    }
+    if (props.twitter) {
+        const tc = props.twitter;
+        if (tc.card)
+            tags.push(`<meta ${MANAGED_ATTR} name="twitter:card" content="${escapeHtml(tc.card)}">`);
+        if (tc.site)
+            tags.push(`<meta ${MANAGED_ATTR} name="twitter:site" content="${escapeHtml(tc.site)}">`);
+        if (tc.creator)
+            tags.push(`<meta ${MANAGED_ATTR} name="twitter:creator" content="${escapeHtml(tc.creator)}">`);
+        if (tc.title)
+            tags.push(`<meta ${MANAGED_ATTR} name="twitter:title" content="${escapeHtml(tc.title)}">`);
+        if (tc.description)
+            tags.push(`<meta ${MANAGED_ATTR} name="twitter:description" content="${escapeHtml(tc.description)}">`);
+        if (tc.image)
+            tags.push(`<meta ${MANAGED_ATTR} name="twitter:image" content="${escapeHtml(tc.image)}">`);
+    }
+    return tags.join('\n');
+}
+function updateClientHead(html) {
+    if (typeof document === 'undefined')
+        return;
+    const parsed = new DOMParser().parseFromString(`<root>${html}</root>`, 'text/html');
+    const newTags = parsed.body.firstChild?.childNodes ?? [];
+    const existing = document.querySelectorAll(`[${MANAGED_ATTR}]`);
+    existing.forEach((el) => el.remove());
+    for (const node of Array.from(newTags)) {
+        if (node.nodeType === Node.ELEMENT_NODE) {
+            const el = node;
+            if (el.tagName === 'TITLE') {
+                document.title = el.textContent ?? '';
+            }
+            else {
+                document.head.appendChild(document.importNode(el, true));
+            }
+        }
+    }
+}
+export function Head(props) {
+    let html = '';
+    if (props.children) {
+        const children = Array.isArray(props.children) ? props.children : [props.children];
+        html = children
+            .map((child) => {
+            if (child == null || child === false)
+                return '';
+            return renderToString(child);
+        })
+            .join('\n');
+    }
+    else {
+        html = buildShorthandTags(props);
+    }
+    registerHeadContent(html);
+    if (typeof document !== 'undefined') {
+        updateClientHead(html);
+    }
+    return null;
+}
+Head.displayName = 'Head';

package/dist/meta/index.js

@@ -0,0 +1,210 @@
+export { Head } from './head.js';
+export { registerHeadContent, drainHeadContent, peekHeadContent, clearHeadContent, } from './head-registry.js';
+export class MetaGenerator {
+    baseUrl;
+    defaultTitle = 'EmberKit App';
+    defaultDescription = 'Built with EmberKit';
+    siteName = 'EmberKit';
+    constructor(baseUrl = 'https://example.com') {
+        this.baseUrl = baseUrl;
+    }
+    generate(data) {
+        const tags = [];
+        tags.push(...this.generateBasicMeta(data));
+        tags.push(...this.generateOpenGraph(data));
+        tags.push(...this.generateTwitter(data));
+        tags.push(...this.generateCanonical(data));
+        tags.push(...this.generateStructuredData(data));
+        return tags.join('\n');
+    }
+    generateBasicMeta(data) {
+        const tags = [];
+        const title = data.title ?? this.defaultTitle;
+        tags.push(`<title>${escapeHtml(title)}</title>`);
+        tags.push(`<meta name="title" content="${escapeHtml(title)}">`);
+        const description = data.description ?? this.defaultDescription;
+        tags.push(`<meta name="description" content="${escapeHtml(description)}">`);
+        if (data.keywords?.length) {
+            tags.push(`<meta name="keywords" content="${escapeHtml(data.keywords.join(', '))}">`);
+        }
+        if (data.author) {
+            tags.push(`<meta name="author" content="${escapeHtml(data.author)}">`);
+        }
+        if (data.robots) {
+            tags.push(`<meta name="robots" content="${escapeHtml(data.robots)}">`);
+        }
+        return tags;
+    }
+    generateOpenGraph(data) {
+        if (!data.openGraph)
+            return [];
+        const og = data.openGraph;
+        const tags = [];
+        tags.push(`<meta property="og:type" content="${og.type ?? 'website'}">`);
+        tags.push(`<meta property="og:title" content="${escapeHtml(og.title ?? data.title ?? '')}">`);
+        tags.push(`<meta property="og:description" content="${escapeHtml(og.description ?? data.description ?? '')}">`);
+        if (og.url) {
+            tags.push(`<meta property="og:url" content="${escapeHtml(og.url)}">`);
+        }
+        if (og.images?.length) {
+            for (const img of og.images) {
+                tags.push(`<meta property="og:image" content="${escapeHtml(img.url)}">`);
+                if (img.width)
+                    tags.push(`<meta property="og:image:width" content="${img.width}">`);
+                if (img.height)
+                    tags.push(`<meta property="og:image:height" content="${img.height}">`);
+                if (img.alt)
+                    tags.push(`<meta property="og:image:alt" content="${escapeHtml(img.alt)}">`);
+            }
+        }
+        if (og.locale) {
+            tags.push(`<meta property="og:locale" content="${escapeHtml(og.locale)}">`);
+        }
+        if (og.siteName) {
+            tags.push(`<meta property="og:site_name" content="${escapeHtml(og.siteName)}">`);
+        }
+        return tags;
+    }
+    generateTwitter(data) {
+        if (!data.twitter)
+            return [];
+        const tc = data.twitter;
+        const tags = [];
+        tags.push(`<meta name="twitter:card" content="${tc.card}">`);
+        if (tc.title)
+            tags.push(`<meta name="twitter:title" content="${escapeHtml(tc.title)}">`);
+        if (tc.description)
+            tags.push(`<meta name="twitter:description" content="${escapeHtml(tc.description)}">`);
+        if (tc.image)
+            tags.push(`<meta name="twitter:image" content="${escapeHtml(tc.image)}">`);
+        if (tc.imageAlt)
+            tags.push(`<meta name="twitter:image:alt" content="${escapeHtml(tc.imageAlt)}">`);
+        if (tc.site)
+            tags.push(`<meta name="twitter:site" content="${escapeHtml(tc.site)}">`);
+        if (tc.creator)
+            tags.push(`<meta name="twitter:creator" content="${escapeHtml(tc.creator)}">`);
+        return tags;
+    }
+    generateCanonical(data) {
+        if (!data.canonical && this.baseUrl) {
+            return [`<link rel="canonical" href="${escapeHtml(this.baseUrl)}">`];
+        }
+        if (data.canonical) {
+            return [`<link rel="canonical" href="${escapeHtml(data.canonical)}">`];
+        }
+        return [];
+    }
+    generateStructuredData(data) {
+        if (!data.structuredData)
+            return [];
+        const json = JSON.stringify(data.structuredData);
+        return [`<script type="application/ld+json">${json}</script>`];
+    }
+}
+export function createMetaGenerator(baseUrl) {
+    return new MetaGenerator(baseUrl);
+}
+export function generateMeta(data, baseUrl) {
+    const generator = new MetaGenerator(baseUrl);
+    return generator.generate(data);
+}
+export function generateBreadcrumbs(items) {
+    const json = JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'BreadcrumbList',
+        itemListElement: items.map((item, index) => ({
+            '@type': 'ListItem',
+            position: index + 1,
+            name: item.name,
+            item: item.url,
+        })),
+    });
+    return `<script type="application/ld+json">${json}</script>`;
+}
+export function generateArticleSchema(data) {
+    return JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'Article',
+        headline: data.title,
+        description: data.description,
+        author: {
+            '@type': 'Person',
+            name: data.author,
+        },
+        datePublished: data.publishedAt,
+        url: data.url,
+        ...(data.image ? { image: data.image } : {}),
+    });
+}
+export function generateProductSchema(data) {
+    return JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'Product',
+        name: data.name,
+        description: data.description,
+        offers: {
+            '@type': 'Offer',
+            price: data.price,
+            priceCurrency: data.currency ?? 'USD',
+            availability: data.availability ?? 'https://schema.org/InStock',
+        },
+        ...(data.image ? { image: data.image } : {}),
+    });
+}
+export function generateLinks(links) {
+    return links
+        .map((link) => {
+        let tag = `<link rel="${link.rel}" href="${escapeHtml(link.href)}"`;
+        if (link.type)
+            tag += ` type="${link.type}"`;
+        if (link.sizes)
+            tag += ` sizes="${link.sizes}"`;
+        return tag + '>';
+    })
+        .join('\n');
+}
+export function generateScripts(scripts) {
+    return scripts
+        .map((script) => {
+        let tag = '<script';
+        if (script.type)
+            tag += ` type="${script.type}"`;
+        if (script.async)
+            tag += ' async';
+        if (script.defer)
+            tag += ' defer';
+        if (script.src)
+            tag += ` src="${escapeHtml(script.src)}"`;
+        if (script.content) {
+            return `${tag}>${script.content}</script>`;
+        }
+        return `${tag}></script>`;
+    })
+        .join('\n');
+}
+function escapeHtml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+export const DEFAULT_META = {
+    title: 'EmberKit',
+    description: 'Minimalist TypeScript-first JSX framework',
+    robots: 'index, follow',
+};
+export function mergeMeta(base, override) {
+    return {
+        ...base,
+        ...override,
+        openGraph: {
+            ...base.openGraph,
+            ...override.openGraph,
+        },
+        twitter: {
+            ...base.twitter,
+            ...override.twitter,
+        },
+    };
+}

package/dist/navigation/helpers/navigation.js

@@ -0,0 +1,53 @@
+export async function navigate(to, options = {}) {
+    const { replace = false, state, viewTransition } = options;
+    if (replace) {
+        history.replaceState(state ? { ...history.state, ...state } : history.state, '', to);
+    }
+    else {
+        history.pushState(state ?? null, '', to);
+    }
+    if (viewTransition) {
+        const viewTransitionOptions = typeof viewTransition === 'boolean'
+            ? {}
+            : viewTransition;
+        await startViewTransition(viewTransitionOptions);
+    }
+    window.dispatchEvent(new PopStateEvent('popstate', { state: history.state }));
+}
+export function redirect(to, status = 302) {
+    const response = new Response(null, {
+        status,
+        headers: {
+            Location: to,
+        },
+    });
+    throw response;
+}
+export function preload(path) {
+    const link = document.createElement('link');
+    link.rel = 'prefetch';
+    link.href = path;
+    link.as = 'document';
+    document.head.appendChild(link);
+}
+export async function startViewTransition(options = {}) {
+    const { skipTransition = false, documentViewTransition = true } = options;
+    if (skipTransition) {
+        return;
+    }
+    if (documentViewTransition && typeof document !== 'undefined' && 'startViewTransition' in document) {
+        const transition = document.startViewTransition(async () => {
+            await Promise.resolve();
+        });
+        await transition.finished;
+    }
+}
+export function reload() {
+    history.go(0);
+}
+export function back() {
+    history.back();
+}
+export function forward() {
+    history.forward();
+}

package/dist/navigation/helpers/useNavigate.js

@@ -0,0 +1,10 @@
+import { navigate as coreNavigate } from './navigation.js';
+export function useNavigate() {
+    return async (path, options = {}) => {
+        const { skipTransition = false, ...navigationOptions } = options;
+        return coreNavigate(path, {
+            ...navigationOptions,
+            viewTransition: skipTransition ? false : true,
+        });
+    };
+}

package/dist/navigation/index.js

@@ -0,0 +1,3 @@
+export * from './types.js';
+export * from './helpers/navigation.js';
+export { useNavigate } from './helpers/useNavigate.js';

package/dist/navigation/types.js

@@ -0,0 +1,2 @@
+export const VIEW_TRANSITION_API_SUPPORTED = typeof document !== 'undefined' &&
+    'startViewTransition' in document;

package/dist/plugin/index.js

@@ -0,0 +1,74 @@
+export class PluginPipeline {
+    plugins = [];
+    hookCache = new Map();
+    addPlugin(plugin) {
+        this.plugins.push(plugin);
+        this.invalidateCache();
+    }
+    removePlugin(name) {
+        this.plugins = this.plugins.filter((p) => p.name !== name);
+        this.invalidateCache();
+    }
+    async runHook(name, context) {
+        const hooks = this.hookCache.get(name) ?? [];
+        for (const callback of hooks) {
+            await callback(context);
+        }
+    }
+    invalidateCache() {
+        this.hookCache.clear();
+    }
+    getPlugins() {
+        return [...this.plugins];
+    }
+}
+export function createPluginContext(config, api) {
+    const hooks = new Map();
+    return {
+        config,
+        api,
+        onHook(name, callback) {
+            const existing = hooks.get(name) ?? [];
+            hooks.set(name, [...existing, callback]);
+        },
+        addWatchFile(_file) {
+            // File watching handled by Vite
+        },
+    };
+}
+export function createPluginAPI() {
+    return {
+        async resolveId(_id, _options) {
+            return null;
+        },
+        async load(_id) {
+            return null;
+        },
+        async transform(_code, _id) {
+            return null;
+        },
+        async render(html) {
+            return html;
+        },
+    };
+}
+export const CORE_PLUGINS = [];
+export async function loadPlugin(name) {
+    try {
+        const module = await import(name);
+        return module.default ?? module;
+    }
+    catch {
+        throw new Error(`Failed to load plugin: ${name}`);
+    }
+}
+export async function resolvePlugins(plugins, config) {
+    const contexts = [];
+    const api = createPluginAPI();
+    for (const plugin of plugins) {
+        const context = createPluginContext(config, api);
+        await plugin.setup(context);
+        contexts.push(context);
+    }
+    return contexts;
+}