@emberkit/core 0.1.2-alpha.0

package/dist/compiler/compiler.js

@@ -0,0 +1,44 @@
+import { compileAttributes, compileChildren } from './helpers/attributes.js';
+export function compileToTemplate(tag, props, children) {
+    const parts = [];
+    parts.push({ type: 'string', value: `<${tag}` });
+    const attributeParts = compileAttributes(props);
+    parts.push(...attributeParts);
+    parts.push({ type: 'string', value: '>' });
+    const childrenParts = compileChildren(children);
+    parts.push(...childrenParts);
+    parts.push({ type: 'string', value: `</${tag}>` });
+    return {
+        parts,
+        dependencies: [],
+    };
+}
+export function compileSelfClosing(tag, props) {
+    const parts = [];
+    parts.push({ type: 'string', value: `<${tag}` });
+    const attributeParts = compileAttributes(props);
+    parts.push(...attributeParts);
+    parts.push({ type: 'string', value: '/>' });
+    return {
+        parts,
+        dependencies: [],
+    };
+}
+export function compileTextContent(text) {
+    return {
+        parts: [{ type: 'string', value: text }],
+        dependencies: [],
+    };
+}
+export function assembleTemplate(parts) {
+    let result = '';
+    for (const part of parts) {
+        if (part.type === 'string') {
+            result += part.value;
+        }
+        else {
+            result += '${' + part.value + '}';
+        }
+    }
+    return result;
+}

package/dist/compiler/helpers/attributes.js

@@ -0,0 +1,35 @@
+import { escapeString } from './utils.js';
+export function compileAttributes(props) {
+    const parts = [];
+    for (const [key, value] of Object.entries(props)) {
+        if (key === 'children' || key === 'key')
+            continue;
+        if (value === true) {
+            parts.push({ type: 'string', value: ` ${key}` });
+        }
+        else if (value === false) {
+            continue;
+        }
+        else if (typeof value === 'string') {
+            parts.push({ type: 'string', value: ` ${key}="${escapeString(value)}"` });
+        }
+        else {
+            parts.push({ type: 'string', value: ` ${key}=` });
+            parts.push({ type: 'expression', value: String(value) });
+            parts.push({ type: 'string', value: '"' });
+        }
+    }
+    return parts;
+}
+export function compileChildren(children) {
+    const parts = [];
+    for (const child of children) {
+        if (typeof child === 'string') {
+            parts.push({ type: 'string', value: escapeString(child) });
+        }
+        else {
+            parts.push({ type: 'expression', value: String(child) });
+        }
+    }
+    return parts;
+}

package/dist/compiler/helpers/utils.js

@@ -0,0 +1,31 @@
+export function escapeString(str) {
+    return str.replace(/[`\\${}]/g, '\\$&');
+}
+export function generateTemplateParts(parts) {
+    const templateParts = [];
+    const expressions = [];
+    for (const part of parts) {
+        if (part.type === 'string') {
+            templateParts.push(escapeString(part.value));
+        }
+        else {
+            templateParts.push('${');
+            templateParts.push(part.value);
+            templateParts.push('}');
+            expressions.push(part.value);
+        }
+    }
+    return {
+        template: '`' + templateParts.join('') + '`',
+        expressions,
+    };
+}
+export function toKebabCase(str) {
+    return str.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
+}
+export function isValidComponentName(name) {
+    return /^[A-Z]/.test(name) || name === 'Fragment';
+}
+export function isHtmlElement(name) {
+    return /^[a-z]/.test(name);
+}

package/dist/compiler/index.js

@@ -0,0 +1,4 @@
+export * from './types.js';
+export * from './compiler.js';
+export * from './helpers/utils.js';
+export * from './helpers/attributes.js';

package/dist/compiler/types.js

@@ -0,0 +1,3 @@
+export const FRAGMENT_TYPE = 'Fragment';
+export const KEY_PROPERTY = '__key';
+export const CHILDREN_PROPERTY = 'children';

package/dist/context/index.js

@@ -0,0 +1,51 @@
+const contextRegistry = new Map();
+const contextValues = new Map();
+export function createContext(defaultValue) {
+    const context = {
+        id: Symbol('emberkit.context'),
+        defaultValue,
+    };
+    contextRegistry.set(context.id, context);
+    const Provider = createContextProvider(context);
+    return {
+        id: context.id,
+        defaultValue,
+        Provider,
+        use: () => useContext(context),
+    };
+}
+export function setContextValue(context, value) {
+    contextValues.set(context.id, value);
+}
+export function getContextValue(context) {
+    const value = contextValues.get(context.id);
+    if (value === undefined)
+        return context.defaultValue;
+    return value;
+}
+export function hasContext(context) {
+    return contextRegistry.has(context.id);
+}
+export function clearAllContexts() {
+    contextRegistry.clear();
+    contextValues.clear();
+}
+export function useContext(context) {
+    const value = contextValues.get(context.id);
+    if (value === undefined) {
+        if (context.defaultValue === undefined) {
+            throw new Error(`Context ${String(context.id)} has no value`);
+        }
+        return context.defaultValue;
+    }
+    return value;
+}
+export function createContextProvider(context) {
+    return function Provider(props) {
+        setContextValue(context, props.value);
+        return {
+            type: 'Fragment',
+            props: { children: props.children },
+        };
+    };
+}

package/dist/context/types.js

@@ -0,0 +1 @@
+export const CONTEXT_MARKER = Symbol.for('emberkit.context');

package/dist/dev-server/index.js

@@ -0,0 +1,121 @@
+export class DevServer {
+    server = null;
+    options;
+    startTime = 0;
+    requestCount = 0;
+    errorCount = 0;
+    constructor(options = {}) {
+        this.options = {
+            port: options.port ?? 3000,
+            host: options.host ?? 'localhost',
+            cors: options.cors ?? true,
+            hmr: options.hmr ?? true,
+        };
+    }
+    async start() {
+        this.startTime = Date.now();
+        const http = await import('http');
+        const handler = this.createRequestHandler();
+        this.server = http.createServer(handler);
+        await new Promise((resolve, reject) => {
+            this.server.listen(this.options.port, this.options.host, () => {
+                console.log(`Dev server running at http://${this.options.host}:${this.options.port}`);
+                resolve();
+            });
+            this.server.on('error', (err) => {
+                console.error('Server error:', err);
+                reject(err);
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve, reject) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this.server = null;
+                    resolve();
+                }
+            });
+        });
+    }
+    getStats() {
+        return {
+            uptime: Date.now() - this.startTime,
+            requests: this.requestCount,
+            errors: this.errorCount,
+            memoryUsage: process.memoryUsage(),
+        };
+    }
+    createRequestHandler() {
+        return async (req, res) => {
+            this.requestCount++;
+            try {
+                await this.handleRequest(req, res);
+            }
+            catch (error) {
+                this.errorCount++;
+                console.error('Request error:', error);
+                this.sendError(res, 500, 'Internal Server Error');
+            }
+        };
+    }
+    async handleRequest(req, res) {
+        const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
+        if (url.pathname === '/__emberkit_hmr') {
+            this.handleWebSocket(req, res);
+            return;
+        }
+        if (this.options.cors) {
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+        }
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
+            return;
+        }
+        res.setHeader('Content-Type', 'text/html');
+        res.setHeader('Cache-Control', 'no-cache');
+        const html = await this.generateHTML(url.pathname);
+        res.writeHead(200);
+        res.end(html);
+    }
+    handleWebSocket(req, res) {
+        res.writeHead(101, {
+            'Upgrade': 'websocket',
+            'Connection': 'Upgrade',
+        });
+        res.end();
+    }
+    async generateHTML(pathname) {
+        return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>EmberKit Dev</title>
+  <script type="module" src="/@vite/client"></script>
+</head>
+<body>
+  <div id="app"></div>
+</body>
+</html>`;
+    }
+    sendError(res, code, message) {
+        res.writeHead(code, { 'Content-Type': 'text/plain' });
+        res.end(message);
+    }
+}
+export async function createDevServer(options) {
+    const server = new DevServer(options);
+    await server.start();
+    return server;
+}

package/dist/forms/index.js

@@ -0,0 +1,164 @@
+export class FormValidator {
+    schema;
+    constructor(schema) {
+        this.schema = schema;
+    }
+    validate(data) {
+        const errors = {};
+        for (const [field, validator] of Object.entries(this.schema.fields)) {
+            const value = data[field];
+            const error = this.validateField(field, value, validator);
+            if (error) {
+                errors[field] = error;
+            }
+        }
+        return errors;
+    }
+    validateField(name, value, validator) {
+        if (validator.required && (value === undefined || value === null || value === '')) {
+            return `${name} is required`;
+        }
+        if (typeof value === 'string') {
+            if (validator.minLength && value.length < validator.minLength) {
+                return `${name} must be at least ${validator.minLength} characters`;
+            }
+            if (validator.maxLength && value.length > validator.maxLength) {
+                return `${name} must be at most ${validator.maxLength} characters`;
+            }
+            if (validator.pattern && !validator.pattern.test(value)) {
+                return `${name} is invalid`;
+            }
+        }
+        if (validator.custom) {
+            const customError = validator.custom(value);
+            if (customError) {
+                return customError;
+            }
+        }
+        return undefined;
+    }
+    validateFieldOnly(name, value) {
+        const validator = this.schema.fields[name];
+        if (!validator)
+            return undefined;
+        return this.validateField(name, value, validator);
+    }
+}
+export function createFormValidator(schema) {
+    return new FormValidator(schema);
+}
+export function parseFormData(form) {
+    const formData = new FormData(form);
+    const data = {};
+    for (const [key, value] of formData.entries()) {
+        if (data[key] !== undefined) {
+            if (!Array.isArray(data[key])) {
+                data[key] = [data[key]];
+            }
+            data[key].push(value);
+        }
+        else {
+            data[key] = value;
+        }
+    }
+    return data;
+}
+export function createFormState(initial = {}) {
+    return {
+        values: { ...initial },
+        errors: {},
+        touched: new Set(),
+        dirty: false,
+        submitting: false,
+        submitted: false,
+    };
+}
+export function updateFormState(state, updates) {
+    return { ...state, ...updates };
+}
+export function getFieldValue(state, name) {
+    return state.values[name];
+}
+export function setFieldValue(state, name, value) {
+    return {
+        ...state,
+        values: { ...state.values, [name]: value },
+        dirty: true,
+    };
+}
+export function setFieldError(state, name, error) {
+    return {
+        ...state,
+        errors: { ...state.errors, [name]: error },
+    };
+}
+export function clearFormState(state) {
+    return {
+        values: {},
+        errors: {},
+        touched: new Set(),
+        dirty: false,
+        submitting: false,
+        submitted: false,
+    };
+}
+export async function handleFormSubmit(event, config) {
+    event.preventDefault();
+    const form = event.target;
+    const data = parseFormData(form);
+    if (config.validation) {
+        const validator = new FormValidator(config.validation);
+        const errors = validator.validate(data);
+        if (Object.keys(errors).length > 0) {
+            config.onError?.(errors, event);
+            return false;
+        }
+    }
+    if (config.onSubmit) {
+        const formData = new FormData(form);
+        try {
+            await config.onSubmit(formData, event);
+            return true;
+        }
+        catch (err) {
+            return false;
+        }
+    }
+    return true;
+}
+export const DEFAULT_VALIDATORS = {
+    email: {
+        pattern: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
+        custom: (v) => typeof v === 'string' && !v.includes('@') ? 'Invalid email' : null,
+    },
+    url: {
+        pattern: /^https?:\/\/.+/,
+    },
+    phone: {
+        pattern: /^\+?[\d\s-]{10,}$/,
+    },
+};
+export function applyDefaultValidator(field, validator) {
+    const defaultValidator = DEFAULT_VALIDATORS[field];
+    if (!defaultValidator)
+        return validator;
+    return {
+        ...defaultValidator,
+        ...validator,
+        custom: (value) => {
+            const defaultError = defaultValidator.custom?.(value);
+            if (defaultError)
+                return defaultError;
+            return validator.custom?.(value);
+        },
+    };
+}
+export function buildFormAction(action, method, params) {
+    const url = new URL(action, 'http://localhost');
+    if (params) {
+        for (const [key, value] of Object.entries(params)) {
+            url.searchParams.set(key, value);
+        }
+    }
+    return url.toString();
+}