create-lego-one 2.0.10 → 2.0.13

package/template/host/src/kernel/components/ui/use-toast.ts

@@ -0,0 +1,183 @@
+import * as React from 'react';
+
+const TOAST_LIMIT = 1;
+const TOAST_REMOVE_DELAY = 1000000;
+
+type ToasterToast = {
+  id: string;
+  title?: React.ReactNode;
+  description?: React.ReactNode;
+  action?: React.ReactNode;
+  variant?: 'default' | 'destructive';
+  open?: boolean;
+};
+
+const actionTypes = {
+  ADD_TOAST: 'ADD_TOAST',
+  UPDATE_TOAST: 'UPDATE_TOAST',
+  DISMISS_TOAST: 'DISMISS_TOAST',
+  REMOVE_TOAST: 'REMOVE_TOAST',
+} as const;
+
+let count = 0;
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER;
+  return count.toString();
+}
+
+type ActionType = typeof actionTypes;
+
+type Action =
+  | {
+      type: ActionType['ADD_TOAST'];
+      toast: ToasterToast;
+    }
+  | {
+      type: ActionType['UPDATE_TOAST'];
+      toast: Partial<ToasterToast>;
+    }
+  | {
+      type: ActionType['DISMISS_TOAST'];
+      toastId?: ToasterToast['id'];
+    }
+  | {
+      type: ActionType['REMOVE_TOAST'];
+      toastId?: ToasterToast['id'];
+    };
+
+interface State {
+  toasts: ToasterToast[];
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>();
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return;
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId);
+    dispatch({
+      type: 'REMOVE_TOAST',
+      toastId: toastId,
+    });
+  }, TOAST_REMOVE_DELAY);
+
+  toastTimeouts.set(toastId, timeout);
+};
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case 'ADD_TOAST':
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      };
+
+    case 'UPDATE_TOAST':
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast.id ? { ...t, ...action.toast } : t
+        ),
+      };
+
+    case 'DISMISS_TOAST': {
+      const { toastId } = action;
+
+      if (toastId) {
+        addToRemoveQueue(toastId);
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id);
+        });
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t
+        ),
+      };
+    }
+    case 'REMOVE_TOAST':
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        };
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      };
+  }
+};
+
+const listeners: Array<(state: State) => void> = [];
+
+let memoryState: State = { toasts: [] };
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action);
+  listeners.forEach((listener) => {
+    listener(memoryState);
+  });
+}
+
+type Toast = Omit<ToasterToast, 'id'>;
+
+function toast({ ...props }: Toast) {
+  const id = genId();
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: 'UPDATE_TOAST',
+      toast: { ...props, id },
+    });
+  const dismiss = () => dispatch({ type: 'DISMISS_TOAST', toastId: id });
+
+  dispatch({
+    type: 'ADD_TOAST',
+    toast: {
+      ...props,
+      id,
+      open: true,
+    },
+  });
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  };
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState);
+
+  React.useEffect(() => {
+    listeners.push(setState);
+    return () => {
+      const index = listeners.indexOf(setState);
+      if (index > -1) {
+        listeners.splice(index, 1);
+      }
+    };
+  }, [state]);
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: 'DISMISS_TOAST', toastId }),
+  };
+}
+
+export { useToast, toast };

package/template/host/src/kernel/index.ts

@@ -0,0 +1,48 @@
+// Re-export all kernel modules
+export * from './shared-state';
+export * from './providers';
+export * from './lib/utils';
+
+// UI Components
+export * from './components/index';
+
+// Channels
+export * from './channels';
+
+// Plugins
+export * from './plugins';
+
+// Auth
+export type { LoginCredentials, RegisterData, AuthResponse, AuthError } from './auth/types';
+export { AuthService } from './auth/service';
+export { useAuth, useCurrentUser, useRequireAuth } from './auth/hooks';
+export { ProtectedRoute } from './auth/ProtectedRoute';
+
+// RBAC
+export type {
+  Organization,
+  CreateOrganizationData,
+  UpdateOrganizationData,
+  Role,
+  CreateRoleData,
+  UpdateRoleData,
+  Permission,
+  UserRole,
+  AssignRoleData,
+  UserWithRoles,
+  CreateUserRequest,
+  UpdateUserRequest,
+  PermissionCheck,
+  ResourceType,
+  ActionType,
+} from './rbac/types';
+export { RBACService } from './rbac/service';
+export {
+  useCurrentOrganization,
+  useOrganizations,
+  useOrganizationRoles,
+  useHasPermission,
+  useRequirePermission,
+} from './rbac/hooks';
+export { PermissionGate } from './rbac/components/PermissionGate';
+export { OrganizationSelector } from './rbac/components/OrganizationSelector';

package/template/host/src/kernel/lib/cn.ts

@@ -0,0 +1 @@
+export { cn } from './utils';

package/template/host/src/kernel/lib/utils.ts

@@ -0,0 +1,36 @@
+import { type ClassValue, clsx } from 'clsx';
+import { twMerge } from 'tailwind-merge';
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export function getInitials(name: string): string {
+  return name
+    .split(' ')
+    .map((n) => n[0])
+    .join('')
+    .toUpperCase()
+    .slice(0, 2);
+}
+
+export function formatDate(date: string | Date): string {
+  return new Intl.DateTimeFormat('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric',
+  }).format(new Date(date));
+}
+
+export function formatRelativeTime(date: string | Date): string {
+  const now = new Date();
+  const past = new Date(date);
+  const diffInSeconds = Math.floor((now.getTime() - past.getTime()) / 1000);
+
+  if (diffInSeconds < 60) return 'just now';
+  if (diffInSeconds < 3600) return `${Math.floor(diffInSeconds / 60)}m ago`;
+  if (diffInSeconds < 86400) return `${Math.floor(diffInSeconds / 3600)}h ago`;
+  if (diffInSeconds < 604800) return `${Math.floor(diffInSeconds / 86400)}d ago`;
+
+  return formatDate(date);
+}

package/template/host/src/kernel/plugins/Slot.tsx

@@ -0,0 +1,41 @@
+import { useSlots } from './SlotProvider';
+import type { SlotName, SlotInjection } from './types';
+
+interface SlotProps {
+  name: SlotName;
+  children?: React.ReactNode; // Fallback content
+  className?: string;
+}
+
+/**
+ * Slot - Component that renders injected content from plugins
+ *
+ * Plugins can register content to be rendered in specific slots
+ * throughout the host layout (sidebar, topbar, etc.)
+ */
+export function Slot({ name, children, className }: SlotProps) {
+  const { getSlotContent } = useSlots();
+
+  const content = getSlotContent(name);
+
+  if (!content || content.length === 0) {
+    return <>{children}</>;
+  }
+
+  return (
+    <div className={className}>
+      {content.map((item: SlotInjection, index: number) => (
+        <div key={`${item.slot}-${index}`} className="slot-item">
+          {item.condition === undefined || item.condition() ? (
+            typeof item.component === 'function' ? (
+              <item.component {...(item.props || {})} />
+            ) : (
+              item.component
+            )
+          ) : null}
+        </div>
+      ))}
+      {children}
+    </div>
+  );
+}

package/template/host/src/kernel/plugins/SlotProvider.tsx

@@ -0,0 +1,88 @@
+import { createContext, useContext, ReactNode } from 'react';
+import type { SlotInjection, SlotName } from './types';
+import { usePluginStore } from './store';
+import { pluginLoader } from './loader';
+
+interface SlotContextValue {
+  getSlotContent: (name: SlotName) => SlotInjection[];
+  registerSlot: (name: SlotName, injection: SlotInjection) => void;
+  unregisterSlot: (name: SlotName, component: ReactNode) => void;
+}
+
+const SlotContext = createContext<SlotContextValue | null>(null);
+
+interface SlotProviderProps {
+  children: ReactNode;
+}
+
+/**
+ * SlotProvider - Provides slot injection system to the app
+ *
+ * This provider:
+ * 1. Collects slot injections from all enabled plugins
+ * 2. Sorts them by order
+ * 3. Provides getSlotContent function for Slot components
+ */
+export function SlotProvider({ children }: SlotProviderProps) {
+  const plugins = usePluginStore((state) => state.plugins);
+
+  /**
+   * Get all content for a slot from enabled plugins
+   */
+  const getSlotContent = (name: SlotName): SlotInjection[] => {
+    const injections: SlotInjection[] = [];
+
+    // Collect injections from all enabled plugins
+    for (const plugin of Object.values(plugins)) {
+      if (!plugin.enabled || !plugin.loaded) continue;
+
+      const config = pluginLoader.getPluginConfig(plugin.id);
+      if (!config) continue;
+
+      for (const slot of config.slots) {
+        if (slot.slot === name) {
+          injections.push(slot);
+        }
+      }
+    }
+
+    // Sort by order (lower = higher priority = first)
+    return injections.sort((a, b) => (a.order || 100) - (b.order || 100));
+  };
+
+  /**
+   * Register a slot injection (for dynamic registration)
+   */
+  const registerSlot = (name: SlotName, injection: SlotInjection) => {
+    // This would be used for runtime slot registration
+    // For now, slots are registered via plugin config
+    console.log('[SlotProvider] Register slot:', name);
+  };
+
+  /**
+   * Unregister a slot injection
+   */
+  const unregisterSlot = (name: SlotName, component: ReactNode) => {
+    console.log('[SlotProvider] Unregister slot:', name);
+  };
+
+  return (
+    <SlotContext.Provider value={{ getSlotContent, registerSlot, unregisterSlot }}>
+      {children}
+    </SlotContext.Provider>
+  );
+}
+
+/**
+ * Hook to access slot context
+ */
+export function useSlots() {
+  const context = useContext(SlotContext);
+  if (!context) {
+    throw new Error('useSlots must be used within SlotProvider');
+  }
+  return context;
+}
+
+// Export SlotContext for use in Slot component
+export { SlotContext };

package/template/host/src/kernel/plugins/index.ts

@@ -0,0 +1,23 @@
+/**
+ * Plugin System - Barrel Export
+ *
+ * Exports all plugin system functionality for use throughout the host application
+ * and for plugin developers.
+ */
+
+// Types and interfaces
+export * from './types';
+
+// Zod schemas
+export * from './schemas';
+
+// Zustand store
+export * from './store';
+
+// Plugin loader
+export * from './loader';
+
+// Slot components
+export * from './Slot';
+export * from './SlotProvider';
+export { useSlots } from './SlotProvider';

package/template/host/src/kernel/plugins/loader.ts

@@ -0,0 +1,122 @@
+import Garfish from 'garfish';
+import type { PluginConfig, PluginManifest } from './types';
+import { usePluginStore } from './store';
+
+/**
+ * Plugin loader - handles dynamic loading of plugins
+ */
+class PluginLoader {
+  private garfishInstance: typeof Garfish | null = null;
+  private loadedPlugins = new Map<string, PluginConfig>();
+
+  /**
+   * Initialize loader with Garfish instance
+   */
+  initialize(garfish: typeof Garfish): void {
+    this.garfishInstance = garfish;
+    console.log('[PluginLoader] Initialized');
+  }
+
+  /**
+   * Load a plugin dynamically
+   */
+  async loadPlugin(entry: string | (() => Promise<unknown>)): Promise<PluginConfig | null> {
+    if (!this.garfishInstance) {
+      console.error('[PluginLoader] Garfish not initialized');
+      return null;
+    }
+
+    try {
+      let module: any;
+
+      if (typeof entry === 'function') {
+        // Dynamic import (production)
+        module = await entry();
+      } else {
+        // URL load (development)
+        // In dev, plugins run on separate servers
+        // We just track them, actual loading is handled by Garfish
+        console.log(`[PluginLoader] Dev mode: Plugin at ${entry}`);
+        return null;
+      }
+
+      // Extract plugin config from module
+      const config = module.default?.config || module.config;
+
+      if (!config) {
+        console.error('[PluginLoader] Plugin has no config export');
+        return null;
+      }
+
+      // Validate config
+      this.loadedPlugins.set(config.manifest.name, config);
+
+      console.log(`[PluginLoader] Loaded plugin: ${config.manifest.name}`);
+
+      return config;
+    } catch (error) {
+      console.error('[PluginLoader] Failed to load plugin:', error);
+      return null;
+    }
+  }
+
+  /**
+   * Load all configured plugins
+   */
+  async loadPlugins(plugins: Array<{
+    name: string;
+    entry: string | (() => Promise<unknown>);
+  }>): Promise<void> {
+    const store = usePluginStore.getState();
+
+    for (const plugin of plugins) {
+      const state = store.plugins[plugin.name];
+
+      if (!state || !state.enabled) {
+        continue;
+      }
+
+      try {
+        const config = await this.loadPlugin(plugin.entry);
+
+        if (config) {
+          store.registerPlugin(config);
+          store.setPluginLoaded(plugin.name, true);
+        }
+      } catch (error: any) {
+        store.setPluginError(plugin.name, error.message);
+      }
+    }
+  }
+
+  /**
+   * Get loaded plugin config
+   */
+  getPluginConfig(name: string): PluginConfig | undefined {
+    return this.loadedPlugins.get(name);
+  }
+
+  /**
+   * Get all loaded plugins
+   */
+  getAllPlugins(): PluginConfig[] {
+    return Array.from(this.loadedPlugins.values());
+  }
+
+  /**
+   * Check if plugin is loaded
+   */
+  isLoaded(name: string): boolean {
+    return this.loadedPlugins.has(name);
+  }
+}
+
+// Export singleton
+export const pluginLoader = new PluginLoader();
+
+/**
+ * Initialize plugin loader (call from bootstrap)
+ */
+export function initializePluginLoader(garfish: typeof Garfish): void {
+  pluginLoader.initialize(garfish);
+}

package/template/host/src/kernel/plugins/schemas.ts

@@ -0,0 +1,54 @@
+import { z } from 'zod';
+import { SlotName } from './types';
+
+/**
+ * Slot injection schema
+ */
+export const slotInjectionSchema = z.object({
+  slot: z.nativeEnum(SlotName),
+  component: z.any(), // React component
+  order: z.number().optional().default(100),
+  props: z.record(z.any()).optional(),
+  condition: z.function().optional(),
+});
+
+/**
+ * Plugin manifest schema
+ */
+export const pluginManifestSchema = z.object({
+  name: z.string().regex(/^@lego\/plugin-/, 'Plugin name must start with @lego/plugin-'),
+  version: z.string().regex(/^\d+\.\d+\.\d+$/, 'Version must be semver'),
+  displayName: z.string().min(1).max(50),
+  description: z.string().max(500),
+  author: z.string().optional(),
+  icon: z.string().optional(),
+  permissions: z.array(z.string()).optional(),
+});
+
+/**
+ * Plugin config schema
+ */
+export const pluginConfigSchema = z.object({
+  manifest: pluginManifestSchema,
+  enabled: z.boolean().default(true),
+  slots: z.array(slotInjectionSchema).default([]),
+  routes: z.array(z.object({
+    path: z.string(),
+    component: z.any(),
+    protected: z.boolean().optional(),
+    permissions: z.array(z.string()).optional(),
+  })).optional(),
+  settings: z.array(z.object({
+    key: z.string(),
+    type: z.enum(['boolean', 'string', 'number', 'select']),
+    label: z.string(),
+    description: z.string().optional(),
+    defaultValue: z.any(),
+    options: z.array(z.object({
+      label: z.string(),
+      value: z.string(),
+    })).optional(),
+  })).optional(),
+});
+
+export type PluginConfigInput = z.infer<typeof pluginConfigSchema>;