@rajeev02/app-shell 0.1.0

package/src/chat/index.ts

@@ -0,0 +1,260 @@
+/**
+ * @rajeev02/app-shell — Chat Module
+ * Real-time messaging with offline queue, typing indicators, media messages, read receipts
+ */
+
+export type MessageType =
+  | "text"
+  | "image"
+  | "video"
+  | "audio"
+  | "document"
+  | "location"
+  | "contact"
+  | "sticker";
+export type MessageStatus =
+  | "sending"
+  | "sent"
+  | "delivered"
+  | "read"
+  | "failed";
+
+export interface ChatMessage {
+  id: string;
+  roomId: string;
+  senderId: string;
+  type: MessageType;
+  content: string;
+  mediaUrl?: string;
+  thumbnailUrl?: string;
+  mediaSizeBytes?: number;
+  replyTo?: string;
+  forwardedFrom?: string;
+  status: MessageStatus;
+  timestamp: number;
+  editedAt?: number;
+  deletedAt?: number;
+  reactions?: Record<string, string[]>;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ChatRoom {
+  id: string;
+  name?: string;
+  type: "direct" | "group" | "channel" | "support";
+  participants: string[];
+  lastMessage?: ChatMessage;
+  unreadCount: number;
+  muted: boolean;
+  pinned: boolean;
+  createdAt: number;
+  updatedAt: number;
+}
+
+export interface TypingIndicator {
+  roomId: string;
+  userId: string;
+  isTyping: boolean;
+  timestamp: number;
+}
+
+/**
+ * Chat Engine — manages rooms, messages, offline queue
+ */
+export class ChatEngine {
+  private rooms: Map<string, ChatRoom> = new Map();
+  private messages: Map<string, ChatMessage[]> = new Map();
+  private offlineQueue: ChatMessage[] = [];
+  private typingUsers: Map<string, Set<string>> = new Map();
+  private listeners: Map<string, Set<(event: ChatEvent) => void>> = new Map();
+  private currentUserId: string;
+
+  constructor(userId: string) {
+    this.currentUserId = userId;
+  }
+
+  /** Send a text message */
+  sendMessage(
+    roomId: string,
+    content: string,
+    type: MessageType = "text",
+    replyTo?: string,
+  ): ChatMessage {
+    const message: ChatMessage = {
+      id: `msg_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+      roomId,
+      senderId: this.currentUserId,
+      type,
+      content,
+      status: "sending",
+      timestamp: Date.now(),
+      replyTo,
+    };
+    this.addMessage(roomId, message);
+    this.offlineQueue.push(message);
+    this.emit(roomId, { type: "message_sent", message });
+    return message;
+  }
+
+  /** Receive a message (from server/websocket) */
+  receiveMessage(message: ChatMessage): void {
+    this.addMessage(message.roomId, message);
+    this.updateRoom(message.roomId, { lastMessage: message });
+    this.emit(message.roomId, { type: "message_received", message });
+  }
+
+  /** Mark a message as delivered/read */
+  updateMessageStatus(
+    messageId: string,
+    roomId: string,
+    status: MessageStatus,
+  ): void {
+    const messages = this.messages.get(roomId);
+    const msg = messages?.find((m) => m.id === messageId);
+    if (msg) {
+      msg.status = status;
+      this.emit(roomId, { type: "status_update", messageId, status });
+    }
+  }
+
+  /** Mark all messages in room as read */
+  markRoomAsRead(roomId: string): void {
+    const room = this.rooms.get(roomId);
+    if (room) {
+      room.unreadCount = 0;
+    }
+    this.emit(roomId, { type: "room_read", roomId });
+  }
+
+  /** Delete a message (soft delete) */
+  deleteMessage(messageId: string, roomId: string): void {
+    const messages = this.messages.get(roomId);
+    const msg = messages?.find((m) => m.id === messageId);
+    if (msg) {
+      msg.deletedAt = Date.now();
+      msg.content = "";
+    }
+    this.emit(roomId, { type: "message_deleted", messageId });
+  }
+
+  /** Add reaction */
+  addReaction(messageId: string, roomId: string, emoji: string): void {
+    const messages = this.messages.get(roomId);
+    const msg = messages?.find((m) => m.id === messageId);
+    if (msg) {
+      if (!msg.reactions) msg.reactions = {};
+      if (!msg.reactions[emoji]) msg.reactions[emoji] = [];
+      if (!msg.reactions[emoji].includes(this.currentUserId)) {
+        msg.reactions[emoji].push(this.currentUserId);
+      }
+    }
+  }
+
+  /** Set typing indicator */
+  setTyping(roomId: string, isTyping: boolean): void {
+    this.emit(roomId, { type: "typing", userId: this.currentUserId, isTyping });
+  }
+
+  /** Handle remote typing indicator */
+  onRemoteTyping(roomId: string, userId: string, isTyping: boolean): void {
+    if (!this.typingUsers.has(roomId)) this.typingUsers.set(roomId, new Set());
+    const users = this.typingUsers.get(roomId)!;
+    if (isTyping) users.add(userId);
+    else users.delete(userId);
+    this.emit(roomId, { type: "typing", userId, isTyping });
+  }
+
+  /** Get typing users in a room */
+  getTypingUsers(roomId: string): string[] {
+    return Array.from(this.typingUsers.get(roomId) ?? []);
+  }
+
+  /** Get messages for a room */
+  getMessages(
+    roomId: string,
+    limit: number = 50,
+    before?: number,
+  ): ChatMessage[] {
+    const all = this.messages.get(roomId) ?? [];
+    let filtered = before ? all.filter((m) => m.timestamp < before) : all;
+    return filtered.slice(-limit);
+  }
+
+  /** Get all rooms sorted by last activity */
+  getRooms(): ChatRoom[] {
+    return Array.from(this.rooms.values()).sort(
+      (a, b) => b.updatedAt - a.updatedAt,
+    );
+  }
+
+  /** Get total unread count */
+  getTotalUnread(): number {
+    return Array.from(this.rooms.values()).reduce(
+      (sum, r) => sum + r.unreadCount,
+      0,
+    );
+  }
+
+  /** Get offline queue for syncing */
+  getOfflineQueue(): ChatMessage[] {
+    return [...this.offlineQueue];
+  }
+
+  /** Clear offline queue after successful sync */
+  clearOfflineQueue(): void {
+    this.offlineQueue = [];
+  }
+
+  /** Search messages across rooms */
+  search(query: string, limit: number = 20): ChatMessage[] {
+    const results: ChatMessage[] = [];
+    const lower = query.toLowerCase();
+    for (const messages of this.messages.values()) {
+      for (const msg of messages) {
+        if (msg.content.toLowerCase().includes(lower) && !msg.deletedAt) {
+          results.push(msg);
+          if (results.length >= limit) return results;
+        }
+      }
+    }
+    return results;
+  }
+
+  /** Subscribe to room events */
+  onRoomEvent(
+    roomId: string,
+    listener: (event: ChatEvent) => void,
+  ): () => void {
+    if (!this.listeners.has(roomId)) this.listeners.set(roomId, new Set());
+    this.listeners.get(roomId)!.add(listener);
+    return () => this.listeners.get(roomId)?.delete(listener);
+  }
+
+  private addMessage(roomId: string, message: ChatMessage): void {
+    if (!this.messages.has(roomId)) this.messages.set(roomId, []);
+    this.messages.get(roomId)!.push(message);
+  }
+
+  private updateRoom(roomId: string, updates: Partial<ChatRoom>): void {
+    const room = this.rooms.get(roomId);
+    if (room) Object.assign(room, updates, { updatedAt: Date.now() });
+  }
+
+  private emit(roomId: string, event: ChatEvent): void {
+    const listeners = this.listeners.get(roomId);
+    if (listeners)
+      for (const l of listeners) {
+        try {
+          l(event);
+        } catch {}
+      }
+  }
+}
+
+export type ChatEvent =
+  | { type: "message_sent"; message: ChatMessage }
+  | { type: "message_received"; message: ChatMessage }
+  | { type: "message_deleted"; messageId: string }
+  | { type: "status_update"; messageId: string; status: MessageStatus }
+  | { type: "typing"; userId: string; isTyping: boolean }
+  | { type: "room_read"; roomId: string };

package/src/config/index.ts

@@ -0,0 +1,69 @@
+/**
+ * @rajeev02/app-shell — Feature Flags & Remote Config
+ * A/B testing, gradual rollout, kill switch, remote configuration
+ */
+
+export interface FeatureFlag {
+  key: string;
+  enabled: boolean;
+  rolloutPercent?: number;
+  segments?: string[];
+  variant?: string;
+  metadata?: Record<string, unknown>;
+}
+
+export class FeatureFlagManager {
+  private flags: Map<string, FeatureFlag> = new Map();
+  private config: Map<string, unknown> = new Map();
+  private userId: string = "";
+
+  /** Load flags from server response */
+  loadFlags(flags: FeatureFlag[]): void {
+    for (const f of flags) this.flags.set(f.key, f);
+  }
+
+  /** Load remote config */
+  loadConfig(config: Record<string, unknown>): void {
+    for (const [k, v] of Object.entries(config)) this.config.set(k, v);
+  }
+
+  /** Check if feature is enabled */
+  isEnabled(key: string): boolean {
+    const flag = this.flags.get(key);
+    if (!flag) return false;
+    if (!flag.enabled) return false;
+    if (flag.rolloutPercent !== undefined) {
+      const hash = this.hashUser(this.userId + key);
+      return hash < flag.rolloutPercent;
+    }
+    return true;
+  }
+
+  /** Get A/B variant */
+  getVariant(key: string): string | null {
+    return this.flags.get(key)?.variant ?? null;
+  }
+
+  /** Get config value */
+  getConfig<T = unknown>(key: string, defaultValue: T): T {
+    return (this.config.get(key) as T) ?? defaultValue;
+  }
+
+  /** Set user ID for consistent rollout */
+  setUserId(userId: string): void {
+    this.userId = userId;
+  }
+
+  /** Get all flags */
+  getAllFlags(): FeatureFlag[] {
+    return Array.from(this.flags.values());
+  }
+
+  private hashUser(input: string): number {
+    let hash = 0;
+    for (let i = 0; i < input.length; i++) {
+      hash = ((hash << 5) - hash + input.charCodeAt(i)) | 0;
+    }
+    return Math.abs(hash) % 100;
+  }
+}

package/src/forms/index.ts

@@ -0,0 +1,376 @@
+/**
+ * @rajeev02/app-shell — Form Engine + KYC
+ * Dynamic forms, multi-step wizard, validation, Indian ID verification
+ */
+
+export type FieldType =
+  | "text"
+  | "email"
+  | "phone"
+  | "number"
+  | "password"
+  | "select"
+  | "multiselect"
+  | "checkbox"
+  | "radio"
+  | "date"
+  | "file"
+  | "image"
+  | "aadhaar"
+  | "pan"
+  | "ifsc"
+  | "pincode"
+  | "vpa"
+  | "textarea"
+  | "otp";
+
+export interface FormField {
+  id: string;
+  type: FieldType;
+  label: string;
+  placeholder?: string;
+  required?: boolean;
+  defaultValue?: unknown;
+  validation?: ValidationRule[];
+  options?: { label: string; value: string }[];
+  maxSizeBytes?: number;
+  acceptedTypes?: string[];
+  dependsOn?: { fieldId: string; value: unknown };
+  helpText?: string;
+  masked?: boolean;
+}
+
+export interface ValidationRule {
+  type:
+    | "required"
+    | "minLength"
+    | "maxLength"
+    | "pattern"
+    | "email"
+    | "phone"
+    | "aadhaar"
+    | "pan"
+    | "ifsc"
+    | "pincode"
+    | "custom";
+  value?: unknown;
+  message: string;
+  validator?: (value: unknown) => boolean;
+}
+
+export interface FormStep {
+  id: string;
+  title: string;
+  description?: string;
+  fields: FormField[];
+}
+export interface FormConfig {
+  id: string;
+  title: string;
+  steps: FormStep[];
+  onSubmit?: (
+    data: Record<string, unknown>,
+  ) => Promise<{ success: boolean; error?: string }>;
+}
+
+export interface FormState {
+  currentStep: number;
+  totalSteps: number;
+  values: Record<string, unknown>;
+  errors: Record<string, string>;
+  touched: Record<string, boolean>;
+  isSubmitting: boolean;
+  isDirty: boolean;
+}
+
+export class FormEngine {
+  private config: FormConfig;
+  private state: FormState;
+
+  constructor(config: FormConfig) {
+    this.config = config;
+    this.state = {
+      currentStep: 0,
+      totalSteps: config.steps.length,
+      values: {},
+      errors: {},
+      touched: {},
+      isSubmitting: false,
+      isDirty: false,
+    };
+    for (const step of config.steps)
+      for (const f of step.fields)
+        if (f.defaultValue !== undefined)
+          this.state.values[f.id] = f.defaultValue;
+  }
+
+  setValue(fieldId: string, value: unknown): void {
+    this.state.values[fieldId] = value;
+    this.state.touched[fieldId] = true;
+    this.state.isDirty = true;
+    this.validateField(fieldId);
+  }
+  getValue(fieldId: string): unknown {
+    return this.state.values[fieldId];
+  }
+  getValues(): Record<string, unknown> {
+    return { ...this.state.values };
+  }
+
+  validateField(fieldId: string): string | null {
+    const field = this.config.steps
+      .flatMap((s) => s.fields)
+      .find((f) => f.id === fieldId);
+    if (!field) return null;
+    const value = this.state.values[fieldId];
+    const str = String(value ?? "");
+
+    for (const rule of field.validation ?? []) {
+      let error: string | null = null;
+      switch (rule.type) {
+        case "required":
+          error = !value || str.trim() === "" ? rule.message : null;
+          break;
+        case "minLength":
+          error = str.length < (rule.value as number) ? rule.message : null;
+          break;
+        case "maxLength":
+          error = str.length > (rule.value as number) ? rule.message : null;
+          break;
+        case "pattern":
+          error = !new RegExp(rule.value as string).test(str)
+            ? rule.message
+            : null;
+          break;
+        case "email":
+          error = !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(str) ? rule.message : null;
+          break;
+        case "phone":
+          error = !/^[6-9]\d{9}$/.test(
+            str.replace(/\D/g, "").replace(/^91/, ""),
+          )
+            ? rule.message
+            : null;
+          break;
+        case "aadhaar":
+          error = !/^[2-9]\d{11}$/.test(str.replace(/\s/g, ""))
+            ? rule.message
+            : null;
+          break;
+        case "pan":
+          error = !/^[A-Z]{5}[0-9]{4}[A-Z]$/.test(str.toUpperCase())
+            ? rule.message
+            : null;
+          break;
+        case "ifsc":
+          error = !/^[A-Z]{4}0[A-Z0-9]{6}$/.test(str.toUpperCase())
+            ? rule.message
+            : null;
+          break;
+        case "pincode":
+          error = !/^\d{6}$/.test(str) ? rule.message : null;
+          break;
+        case "custom":
+          error =
+            rule.validator && !rule.validator(value) ? rule.message : null;
+          break;
+      }
+      if (error) {
+        this.state.errors[fieldId] = error;
+        return error;
+      }
+    }
+    delete this.state.errors[fieldId];
+    return null;
+  }
+
+  validateCurrentStep(): boolean {
+    const step = this.config.steps[this.state.currentStep];
+    let valid = true;
+    for (const f of step.fields) {
+      if (this.validateField(f.id)) valid = false;
+    }
+    return valid;
+  }
+
+  nextStep(): boolean {
+    if (!this.validateCurrentStep()) return false;
+    if (this.state.currentStep < this.state.totalSteps - 1) {
+      this.state.currentStep++;
+      return true;
+    }
+    return false;
+  }
+  prevStep(): boolean {
+    if (this.state.currentStep > 0) {
+      this.state.currentStep--;
+      return true;
+    }
+    return false;
+  }
+
+  async submit(): Promise<{ success: boolean; error?: string }> {
+    this.state.isSubmitting = true;
+    try {
+      if (this.config.onSubmit)
+        return await this.config.onSubmit(this.state.values);
+      return { success: true };
+    } finally {
+      this.state.isSubmitting = false;
+    }
+  }
+
+  getState(): FormState {
+    return { ...this.state };
+  }
+  getCurrentStep(): FormStep {
+    return this.config.steps[this.state.currentStep];
+  }
+  reset(): void {
+    this.state = {
+      currentStep: 0,
+      totalSteps: this.config.steps.length,
+      values: {},
+      errors: {},
+      touched: {},
+      isSubmitting: false,
+      isDirty: false,
+    };
+  }
+}
+
+/** Pre-built KYC form */
+export function getKycFormConfig(): FormConfig {
+  return {
+    id: "kyc",
+    title: "Complete KYC",
+    steps: [
+      {
+        id: "personal",
+        title: "Personal Details",
+        fields: [
+          {
+            id: "fullName",
+            type: "text",
+            label: "Full Name (as per Aadhaar)",
+            required: true,
+            validation: [{ type: "required", message: "Name is required" }],
+          },
+          { id: "dob", type: "date", label: "Date of Birth", required: true },
+          {
+            id: "phone",
+            type: "phone",
+            label: "Mobile Number",
+            required: true,
+            validation: [
+              { type: "phone", message: "Enter valid mobile number" },
+            ],
+          },
+          {
+            id: "email",
+            type: "email",
+            label: "Email",
+            validation: [{ type: "email", message: "Enter valid email" }],
+          },
+        ],
+      },
+      {
+        id: "identity",
+        title: "Identity Verification",
+        fields: [
+          {
+            id: "aadhaar",
+            type: "aadhaar",
+            label: "Aadhaar Number",
+            required: true,
+            masked: true,
+            validation: [
+              { type: "aadhaar", message: "Enter valid 12-digit Aadhaar" },
+            ],
+          },
+          {
+            id: "pan",
+            type: "pan",
+            label: "PAN Number",
+            required: true,
+            validation: [
+              { type: "pan", message: "Enter valid PAN (e.g., ABCDE1234F)" },
+            ],
+          },
+        ],
+      },
+      {
+        id: "address",
+        title: "Address",
+        fields: [
+          {
+            id: "address1",
+            type: "text",
+            label: "Address Line 1",
+            required: true,
+          },
+          { id: "city", type: "text", label: "City", required: true },
+          {
+            id: "state",
+            type: "select",
+            label: "State",
+            required: true,
+            options: [
+              { label: "Maharashtra", value: "MH" },
+              { label: "Karnataka", value: "KA" },
+              { label: "Tamil Nadu", value: "TN" },
+              { label: "Delhi", value: "DL" },
+              { label: "West Bengal", value: "WB" },
+              { label: "Uttar Pradesh", value: "UP" },
+            ],
+          },
+          {
+            id: "pincode",
+            type: "pincode",
+            label: "PIN Code",
+            required: true,
+            validation: [
+              { type: "pincode", message: "Enter valid 6-digit PIN" },
+            ],
+          },
+        ],
+      },
+      {
+        id: "documents",
+        title: "Upload Documents",
+        fields: [
+          {
+            id: "aadhaarFront",
+            type: "image",
+            label: "Aadhaar Card (Front)",
+            required: true,
+            maxSizeBytes: 5242880,
+            acceptedTypes: ["image/jpeg", "image/png"],
+          },
+          {
+            id: "aadhaarBack",
+            type: "image",
+            label: "Aadhaar Card (Back)",
+            required: true,
+            maxSizeBytes: 5242880,
+          },
+          {
+            id: "panPhoto",
+            type: "image",
+            label: "PAN Card Photo",
+            required: true,
+            maxSizeBytes: 5242880,
+          },
+          {
+            id: "selfie",
+            type: "image",
+            label: "Live Selfie",
+            required: true,
+            maxSizeBytes: 5242880,
+            helpText: "Take a clear selfie for face verification",
+          },
+        ],
+      },
+    ],
+  };
+}