@mframework/core 0.0.1

package/dist/src/plugins/registry.d.ts

@@ -0,0 +1,14 @@
+import { AlternateModule } from '../types/module';
+import { AlternateContext } from '../runtime/context';
+import { AlternateAdapterKey, AlternateAdapterMap, AlternateAdapterOf } from '../types/adapters';
+import { AlternateEventBus } from '../types/events';
+export declare class ModuleRegistry {
+    private modules;
+    private adapters;
+    private bus;
+    constructor(bus?: AlternateEventBus);
+    registerModule(module: AlternateModule, ctx: AlternateContext): void;
+    getAdapter<K extends AlternateAdapterKey>(key: K): AlternateAdapterOf<K> | undefined;
+    registerAdapter<K extends AlternateAdapterKey>(key: K, adapter: AlternateAdapterMap[K]): void;
+    runLifecycle(hook: keyof AlternateModule, ctx: AlternateContext): Promise<void>;
+}

package/dist/src/plugins/registry.js

@@ -0,0 +1,46 @@
+export class ModuleRegistry {
+    modules = new Map();
+    adapters = new Map();
+    bus = null;
+    constructor(bus) {
+        if (bus)
+            this.bus = bus;
+    }
+    registerModule(module, ctx) {
+        if (this.modules.has(module.id))
+            return;
+        this.modules.set(module.id, module);
+        if (module.adapters) {
+            for (const [key, adapter] of Object.entries(module.adapters)) {
+                const typedKey = key;
+                this.registerAdapter(typedKey, adapter);
+            }
+        }
+        module.setup?.(ctx);
+    }
+    getAdapter(key) {
+        return this.adapters.get(key);
+    }
+    // Register an adapter at runtime. Emits `adapter:registered` so modules
+    // depending on adapters can react when new adapters become available.
+    registerAdapter(key, adapter) {
+        this.adapters.set(key, adapter);
+        if (this.bus) {
+            try {
+                // notify listeners asynchronously
+                this.bus.emit('adapter:registered', { key }).catch(() => { });
+            }
+            catch (e) {
+                // ignore emit errors
+            }
+        }
+    }
+    async runLifecycle(hook, ctx) {
+        for (const module of this.modules.values()) {
+            const fn = module[hook];
+            if (typeof fn === 'function') {
+                await fn.call(module, ctx);
+            }
+        }
+    }
+}

package/dist/src/runtime/app.d.ts

@@ -0,0 +1,6 @@
+import { AlternateConfig } from '../types/config';
+import type { AlternateApp, AlternateAppOptions } from '../types/app';
+export declare function createAlternateApp(options: AlternateAppOptions): AlternateApp;
+export type { AlternateAppOptions };
+export type { AlternateApp };
+export type { AlternateConfig };

package/dist/src/runtime/app.js

@@ -0,0 +1,20 @@
+import { AlternateContext } from './context';
+import { ModuleRegistry } from '../plugins/registry';
+import { createEventBus } from '../types/events';
+import { setRuntimeContext } from './hooks';
+import { runAppLifecycle } from './lifecycle';
+export function createAlternateApp(options) {
+    const eventBus = createEventBus();
+    const registry = new ModuleRegistry(eventBus);
+    const context = new AlternateContext(options.config, registry);
+    setRuntimeContext(context, eventBus);
+    options.modules?.forEach((mod) => registry.registerModule(mod, context));
+    return {
+        context,
+        events: eventBus,
+        async start() {
+            await runAppLifecycle(registry, context, eventBus);
+            return context;
+        }
+    };
+}

package/dist/src/runtime/config.d.ts

@@ -0,0 +1,18 @@
+export declare function defineMeeoviConfig(): {
+    productProvider: string;
+    cartProvider: string;
+    contentProvider: string;
+    authUrl: string;
+    searchUrl: string;
+    adapters: {
+        commerce: string;
+        social: string;
+        search: string;
+        auth: string;
+        chat: string;
+        lists: string;
+    };
+};
+export declare function defineMeeoviTheme(theme: any): any;
+export type MeeoviConfig = ReturnType<typeof defineMeeoviConfig>;
+export type MeeoviTheme = ReturnType<typeof defineMeeoviTheme>;

package/dist/src/runtime/config.js

@@ -0,0 +1,20 @@
+export function defineMeeoviConfig() {
+    return {
+        productProvider: 'directus',
+        cartProvider: 'directus',
+        contentProvider: 'directus',
+        authUrl: '/api/auth',
+        searchUrl: '/api/search',
+        adapters: {
+            commerce: '',
+            social: '',
+            search: '',
+            auth: '',
+            chat: '',
+            lists: ''
+        }
+    };
+}
+export function defineMeeoviTheme(theme) {
+    return theme;
+}

package/dist/src/runtime/context.d.ts

@@ -0,0 +1,9 @@
+import { AlternateConfig } from '../types/config';
+import { ModuleRegistry } from '../plugins/registry';
+import { AlternateAdapterKey, AlternateAdapterOf } from '../types/adapters';
+export declare class AlternateContext {
+    readonly config: AlternateConfig;
+    readonly modules: ModuleRegistry;
+    constructor(config: AlternateConfig, modules: ModuleRegistry);
+    getAdapter<K extends AlternateAdapterKey>(key: K): AlternateAdapterOf<K> | undefined;
+}

package/dist/src/runtime/context.js

@@ -0,0 +1,11 @@
+export class AlternateContext {
+    config;
+    modules;
+    constructor(config, modules) {
+        this.config = config;
+        this.modules = modules;
+    }
+    getAdapter(key) {
+        return this.modules.getAdapter(key);
+    }
+}

package/dist/src/runtime/hooks.d.ts

@@ -0,0 +1,6 @@
+import { AlternateContext } from './context';
+import { AlternateEventBus } from '../types/events';
+export declare function setRuntimeContext(ctx: AlternateContext, bus: AlternateEventBus): void;
+export declare function useAlternateContext(): AlternateContext;
+export declare function useAlternateEventBus(): AlternateEventBus;
+export declare function useRuntimeConfig(): import("./app").AlternateConfig;

package/dist/src/runtime/hooks.js

@@ -0,0 +1,21 @@
+let currentContext = null;
+let currentEventBus = null;
+export function setRuntimeContext(ctx, bus) {
+    currentContext = ctx;
+    currentEventBus = bus;
+}
+export function useAlternateContext() {
+    if (!currentContext) {
+        throw new Error('[@meeovi/core] useAlternateContext() called before app initialization');
+    }
+    return currentContext;
+}
+export function useAlternateEventBus() {
+    if (!currentEventBus) {
+        throw new Error('[@meeovi/core] useAlternateEventBus() called before app initialization');
+    }
+    return currentEventBus;
+}
+export function useRuntimeConfig() {
+    return useAlternateContext().config;
+}

package/dist/src/runtime/lifecycle.d.ts

@@ -0,0 +1,4 @@
+import { AlternateContext } from './context';
+import { ModuleRegistry } from '../plugins/registry';
+import { AlternateEventBus } from '../types/events';
+export declare function runAppLifecycle(registry: ModuleRegistry, ctx: AlternateContext, bus: AlternateEventBus): Promise<void>;

package/dist/src/runtime/lifecycle.js

@@ -0,0 +1,5 @@
+export async function runAppLifecycle(registry, ctx, bus) {
+    // Example lifecycle sequence
+    await registry.runLifecycle('onAppInit', ctx);
+    bus.emit('app:ready', { context: ctx });
+}

package/dist/src/types/adapters.d.ts

@@ -0,0 +1,14 @@
+import type { SearchAdapter } from '../adapters/search';
+import type { ListsAdapter } from '../adapters/lists';
+import type { CatalogAdapter } from '../adapters/catalog';
+import type { CartAdapter } from '../adapters/cart';
+import type { AuthAdapter } from '../adapters/auth';
+export interface AlternateAdapterMap {
+    search: SearchAdapter;
+    lists: ListsAdapter;
+    catalog: CatalogAdapter;
+    cart: CartAdapter;
+    auth: AuthAdapter;
+}
+export type AlternateAdapterKey = keyof AlternateAdapterMap;
+export type AlternateAdapterOf<K extends AlternateAdapterKey> = AlternateAdapterMap[K];

package/dist/src/types/adapters.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/app.d.ts

@@ -0,0 +1,13 @@
+import { AlternateConfig } from './config';
+import { AlternateContext } from '../runtime/context';
+import { AlternateEventBus } from './events';
+import { AlternateModule } from './module';
+export interface AlternateApp {
+    context: AlternateContext;
+    events: AlternateEventBus;
+    start(): Promise<AlternateContext>;
+}
+export interface AlternateAppOptions {
+    config: AlternateConfig;
+    modules?: AlternateModule[];
+}

package/dist/src/types/app.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/auth/adapter.d.ts

@@ -0,0 +1,6 @@
+import { AuthSession } from "./session";
+export interface AuthAdapter {
+    getSession(): Promise<AuthSession | null>;
+    signIn(email: string, password: string): Promise<AuthSession>;
+    signOut(): Promise<void>;
+}

package/dist/src/types/auth/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/auth/inputs.d.ts

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+export declare const LoginInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+}, z.core.$strip>;
+export type LoginInput = z.infer<typeof LoginInputSchema>;
+export declare const RegisterInputSchema: z.ZodObject<{
+    email: z.ZodString;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+}, z.core.$strip>;
+export type RegisterInput = z.infer<typeof RegisterInputSchema>;
+export declare const ForgotPasswordInputSchema: z.ZodObject<{
+    email: z.ZodString;
+}, z.core.$strip>;
+export type ForgotPasswordInput = z.infer<typeof ForgotPasswordInputSchema>;
+export declare const ResetPasswordInputSchema: z.ZodObject<{
+    token: z.ZodString;
+    password: z.ZodString;
+    confirmPassword: z.ZodString;
+}, z.core.$strip>;
+export type ResetPasswordInput = z.infer<typeof ResetPasswordInputSchema>;

package/dist/src/types/auth/inputs.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+export const LoginInputSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(8)
+});
+export const RegisterInputSchema = z.object({
+    email: z.string().email(),
+    password: z.string().min(8),
+    confirmPassword: z.string().min(8)
+}).refine((data) => data.password === data.confirmPassword, {
+    message: 'Passwords do not match',
+    path: ['confirmPassword']
+});
+export const ForgotPasswordInputSchema = z.object({
+    email: z.string().email()
+});
+export const ResetPasswordInputSchema = z.object({
+    token: z.string(),
+    password: z.string().min(8),
+    confirmPassword: z.string().min(8)
+});

package/dist/src/types/auth/providers.d.ts

@@ -0,0 +1,6 @@
+export interface OAuthProvider {
+    id: string;
+    label: string;
+    icon?: string;
+    authUrl: string;
+}

package/dist/src/types/auth/providers.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/auth/session.d.ts

@@ -0,0 +1,7 @@
+import { AuthUser } from "./user";
+export interface AuthSession {
+    user: AuthUser | null;
+    accessToken: string | null;
+    refreshToken?: string | null;
+    expiresAt?: number;
+}

package/dist/src/types/auth/session.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/auth/user.d.ts

@@ -0,0 +1,9 @@
+export interface AuthUser {
+    id: string;
+    email: string;
+    name?: string;
+    avatarUrl?: string;
+    emailVerified: boolean;
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/src/types/auth/user.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/commerce/adapter.d.ts

@@ -0,0 +1,18 @@
+import { CommerceCart } from "./cart";
+import { CommerceCategory } from "./category";
+import { CommerceProduct } from "./product";
+export interface CommerceAdapter {
+    getProductBySlug(slug: string): Promise<CommerceProduct | null>;
+    getProducts(params: {
+        search?: string;
+        categoryId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<CommerceProduct[]>;
+    getCategoryTree(): Promise<CommerceCategory[]>;
+    getCart(cartId: string): Promise<CommerceCart | null>;
+    addToCart(cartId: string | null, input: {
+        productId: string;
+        quantity: number;
+    }): Promise<CommerceCart>;
+}

package/dist/src/types/commerce/adapter.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/commerce/cart.d.ts

@@ -0,0 +1,14 @@
+import { CommercePrice } from "./product";
+export interface CommerceCartItem {
+    id: string;
+    productId: string;
+    quantity: number;
+    price: CommercePrice;
+    [key: string]: unknown;
+}
+export interface CommerceCart {
+    id: string;
+    items: CommerceCartItem[];
+    total: CommercePrice;
+    [key: string]: unknown;
+}

package/dist/src/types/commerce/cart.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/commerce/category.d.ts

@@ -0,0 +1,7 @@
+export interface CommerceCategory {
+    id: string;
+    slug: string;
+    name: string;
+    parentId?: string;
+    children?: CommerceCategory[];
+}

package/dist/src/types/commerce/category.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/commerce/order.d.ts

@@ -0,0 +1,12 @@
+import { CommerceCartItem } from "./cart";
+import { CommercePrice } from "./product";
+export interface Order {
+    id: string;
+    items: CommerceCartItem[];
+    subtotal: CommercePrice;
+    total: CommercePrice;
+    currency: string;
+    status: 'pending' | 'paid' | 'shipped' | 'completed' | 'cancelled';
+    createdAt: string;
+    updatedAt: string;
+}

package/dist/src/types/commerce/order.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/commerce/product.d.ts

@@ -0,0 +1,28 @@
+export interface CommercePrice {
+    amount: number;
+    currency: string;
+}
+export interface CommerceImage {
+    url: string;
+    alt?: string;
+}
+export interface CommerceProduct {
+    id: string;
+    slug: string;
+    sku?: string;
+    name: string;
+    description?: string;
+    shortDescription?: string;
+    price: CommercePrice;
+    images: CommerceImage[];
+    categories?: string[];
+    variants?: CommerceVariant[];
+    attributes?: Record<string, string | number | boolean>;
+}
+export interface CommerceVariant {
+    id: string;
+    sku?: string;
+    name?: string;
+    price?: CommercePrice;
+    attributes?: Record<string, string | number | boolean>;
+}

package/dist/src/types/commerce/product.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/compat/legacy.d.ts

@@ -0,0 +1,21 @@
+export interface Product {
+    id?: string;
+    title?: string;
+    description?: string;
+    price?: number;
+}
+export interface Session {
+    id?: string;
+    userId?: string;
+    token?: string;
+}
+export interface User {
+    id?: string;
+    email?: string;
+    name?: string;
+}
+export type { SearchQuery } from '../search/query';
+export type { SearchResult } from '../search/result';
+export type { AuthSession } from '../auth/session';
+export type { CommerceCart, CommerceCartItem } from '../commerce/cart';
+export type { CommercePrice } from '../commerce/product';

package/dist/src/types/compat/legacy.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/config.d.ts

@@ -0,0 +1,8 @@
+export interface AlternateConfig {
+    env: 'development' | 'production' | 'test';
+    appName?: string;
+    logger?: {
+        level?: 'debug' | 'info' | 'warn' | 'error';
+    };
+    [key: string]: unknown;
+}

package/dist/src/types/config.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/core/common.d.ts

@@ -0,0 +1,2 @@
+export type Maybe<T> = T | null | undefined;
+export type ID = string | number;

package/dist/src/types/core/common.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/core/error.d.ts

@@ -0,0 +1,5 @@
+export type MeeoviErrorCode = 'NETWORK' | 'TIMEOUT' | 'BAD_REQUEST' | 'NOT_FOUND' | 'UNKNOWN';
+export interface MeeoviError extends Error {
+    code: MeeoviErrorCode;
+    cause?: unknown;
+}

package/dist/src/types/core/error.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/core/id.d.ts

@@ -0,0 +1 @@
+export type ID = string;

package/dist/src/types/core/id.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/core/pagination.d.ts

@@ -0,0 +1,6 @@
+export interface Paginated<T> {
+    items: T[];
+    total: number;
+    page: number;
+    pageSize: number;
+}

package/dist/src/types/core/pagination.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/core/result.d.ts

@@ -0,0 +1,9 @@
+export type Ok<T> = {
+    ok: true;
+    data: T;
+};
+export type Err<E = string> = {
+    ok: false;
+    error: E;
+};
+export type Result<T, E = string> = Ok<T> | Err<E>;

package/dist/src/types/core/result.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/core/utility.d.ts

@@ -0,0 +1,5 @@
+export type Maybe<T> = T | null | undefined;
+export type ValueOf<T> = T[keyof T];
+export type DeepPartial<T> = {
+    [K in keyof T]?: T[K] extends object ? DeepPartial<T[K]> : T[K];
+};

package/dist/src/types/core/utility.js

@@ -0,0 +1 @@
+export {};

package/dist/src/types/events.d.ts

@@ -0,0 +1,20 @@
+import { AlternateAdapterKey } from './adapters';
+export interface AlternateEventMap {
+    'app:ready': {
+        context: unknown;
+    };
+    'app:error': {
+        error: unknown;
+    };
+    'adapter:registered': {
+        key: AlternateAdapterKey;
+    };
+}
+export type AlternateEventKey = keyof AlternateEventMap;
+export type AlternateEventHandler<K extends AlternateEventKey> = (payload: AlternateEventMap[K]) => void | Promise<void>;
+export interface AlternateEventBus {
+    on<K extends AlternateEventKey>(event: K, handler: AlternateEventHandler<K>): void;
+    off<K extends AlternateEventKey>(event: K, handler: AlternateEventHandler<K>): void;
+    emit<K extends AlternateEventKey>(event: K, payload: AlternateEventMap[K]): Promise<void>;
+}
+export declare function createEventBus(): AlternateEventBus;

package/dist/src/types/events.js

@@ -0,0 +1,22 @@
+export function createEventBus() {
+    const handlers = new Map();
+    return {
+        on(event, handler) {
+            if (!handlers.has(event)) {
+                handlers.set(event, new Set());
+            }
+            handlers.get(event).add(handler);
+        },
+        off(event, handler) {
+            handlers.get(event)?.delete(handler);
+        },
+        async emit(event, payload) {
+            const set = handlers.get(event);
+            if (!set || set.size === 0)
+                return;
+            for (const handler of set) {
+                await handler(payload);
+            }
+        }
+    };
+}

package/dist/src/types/index.d.ts

@@ -0,0 +1,38 @@
+export * from './core/result';
+export * from './core/utility';
+export * from './core/pagination';
+export * from './core/id';
+export { Maybe } from './core/common';
+export * from './core/error';
+export * from './auth/user';
+export * from './auth/session';
+export * from './auth/providers';
+export * from './auth/inputs';
+export * from './auth/adapter';
+export * from './commerce/product';
+export * from './commerce/cart';
+export * from './commerce/order';
+export * from './commerce/adapter';
+export * from './search/query';
+export * from './search/result';
+export * from './search/facet';
+export * from './search/result';
+export * from './search/opensearch';
+export * from './search/adapter';
+export * from './ui/form';
+export * from './ui/state';
+export * from './ui/pagination';
+export * from './ui/component';
+export type * from './ui/blocks';
+export type * from './ui/content';
+export type * from './ui/meta';
+export type * from './ui/system';
+export type * from './ui/help';
+export type * from './ui/os';
+export type * from './ui/schema';
+export type * from './ui/api/global-search';
+export * from './sdk/errors';
+export * from './sdk/endpoint';
+export * from './sdk/request';
+export * from './sdk/response';
+export * from './sdk/adapter';