App and Page Lifecycle

/**
 * Create a WeChat Mini Program app
 * @param options - App configuration with lifecycle methods and global data
 */
function App<TData extends WechatMiniprogram.App.DataOption>(
  options: WechatMiniprogram.App.Option<TData>
): void;

App({
  globalData: {
    userInfo: null,
    version: '1.0.0'
  },
  onLaunch(options) {
    console.log('App launched with scene:', options.scene);
    // Initialize app
  },
  onShow(options) {
    console.log('App showed');
    // App enters foreground
  },
  onHide() {
    console.log('App hidden');
    // App enters background
  },
  onError(error) {
    console.error('App error:', error);
    // Handle app errors
  }
});

/**
 * Get current app instance
 * @param options - Options for app access
 * @returns App instance with global data and methods
 */
function getApp<T extends WechatMiniprogram.App.Instance>(
  options?: WechatMiniprogram.App.GetAppOption
): T;

interface WechatMiniprogram.App.GetAppOption {
  /** Allow access to app instance during app launch */
  allowDefault?: boolean;
}

// Access app from page or component
const app = getApp();
console.log('App version:', app.globalData.version);
app.globalData.userInfo = { name: 'John' };

// Safe access during launch
const app = getApp({ allowDefault: true });

/**
 * Create a WeChat Mini Program page
 * @param options - Page configuration with data, lifecycle, and methods
 */
function Page<TData extends WechatMiniprogram.Page.DataOption>(
  options: WechatMiniprogram.Page.Option<TData>
): void;

Page({
  data: {
    items: [] as string[],
    loading: false,
    count: 0
  },
  onLoad(query) {
    console.log('Page loaded with query:', query);
    this.loadData();
  },
  onShow() {
    console.log('Page showed');
  },
  onReady() {
    console.log('Page ready - initial render complete');
  },
  onHide() {
    console.log('Page hidden');
  },
  onUnload() {
    console.log('Page unloaded');
  },
  onPullDownRefresh() {
    this.loadData();
    wx.stopPullDownRefresh();
  },
  loadData() {
    this.setData({ loading: true });
    // Load data logic
    this.setData({ loading: false });
  }
});

/**
 * Get current pages stack
 * @returns Array of current page instances
 */
function getCurrentPages<T extends WechatMiniprogram.Page.Instance[]>(): T;

// Get current page stack
const pages = getCurrentPages();
const currentPage = pages[pages.length - 1];
console.log('Current page route:', currentPage.route);

// Access previous page
if (pages.length > 1) {
  const prevPage = pages[pages.length - 2];
  prevPage.setData({ returnValue: 'data from current page' });
}

interface WechatMiniprogram.App.Option<TData> {
  /** App launch - called once when app starts */
  onLaunch?(options: WechatMiniprogram.App.LaunchShowOption): void;
  
  /** App show - called when app enters foreground */
  onShow?(options: WechatMiniprogram.App.LaunchShowOption): void;
  
  /** App hide - called when app enters background */
  onHide?(): void;
  
  /** App error - called when app encounters error */
  onError?(error: string): void;
  
  /** Page not found - called when navigating to non-existent page */
  onPageNotFound?(options: WechatMiniprogram.App.PageNotFoundOption): void;
  
  /** Unhandled rejection - called for unhandled promise rejections */
  onUnhandledRejection?(options: WechatMiniprogram.App.UnhandledRejectionOption): void;
  
  /** Theme change - called when system theme changes */
  onThemeChange?(options: WechatMiniprogram.App.ThemeChangeOption): void;
}

interface WechatMiniprogram.App.LaunchShowOption {
  /** Scene value indicating how the app was launched */
  scene: number;
  /** Launch query parameters */
  query: Record<string, string>;
  /** Share ticket for group sharing */
  shareTicket?: string;
  /** Referrer info */
  referrerInfo?: {
    appId: string;
    extraData?: Record<string, any>;
  };
}

interface WechatMiniprogram.App.PageNotFoundOption {
  /** Path of the page that was not found */
  path: string;
  /** Query parameters */
  query: Record<string, string>;
  /** Whether this is a tab bar page */
  isEntryPage: boolean;
}

interface WechatMiniprogram.App.UnhandledRejectionOption {
  /** Promise rejection reason */
  reason: string;
  /** Promise that was rejected */
  promise: Promise<any>;
}

interface WechatMiniprogram.App.ThemeChangeOption {
  /** Current theme: light or dark */
  theme: 'light' | 'dark';
}

interface WechatMiniprogram.Page.Option<TData> {
  /** Page data */
  data?: TData;
  
  /** Page load - called when page loads */
  onLoad?(query: Record<string, string | undefined>): void;
  
  /** Page show - called when page becomes visible */
  onShow?(): void;
  
  /** Page ready - called after initial render completes */
  onReady?(): void;
  
  /** Page hide - called when page becomes hidden */
  onHide?(): void;
  
  /** Page unload - called when page is destroyed */
  onUnload?(): void;
  
  /** Route done - called when route animation completes */
  onRouteDone?(): void;
  
  /** Pull down refresh - called when user pulls down to refresh */
  onPullDownRefresh?(): void;
  
  /** Reach bottom - called when page scrolls to bottom */
  onReachBottom?(): void;
  
  /** Page scroll - called when page scrolls */
  onPageScroll?(options: WechatMiniprogram.Page.PageScrollOption): void;
  
  /** Tab item tap - called when tab bar item is tapped */
  onTabItemTap?(options: WechatMiniprogram.Page.TabItemTapOption): void;
  
  /** Window resize - called when window size changes */
  onResize?(options: WechatMiniprogram.Page.ResizeOption): void;
  
  /** Share app message - called when sharing to chat */
  onShareAppMessage?(
    options: WechatMiniprogram.Page.ShareAppMessageOption
  ): WechatMiniprogram.Page.CustomShareContent;
  
  /** Share timeline - called when sharing to WeChat Moments */
  onShareTimeline?(): WechatMiniprogram.Page.ShareTimelineContent;
  
  /** Add to favorites - called when adding to favorites */
  onAddToFavorites?(
    options: WechatMiniprogram.Page.AddToFavoritesOption
  ): WechatMiniprogram.Page.AddToFavoritesContent;
  
  /** Save exit state - called when page needs to save state */
  onSaveExitState?(): WechatMiniprogram.Page.ExitState;
}

interface WechatMiniprogram.Page.PageScrollOption {
  /** Vertical scroll position in px */
  scrollTop: number;
}

interface WechatMiniprogram.Page.ShareAppMessageOption {
  /** Share trigger: button, menu */
  from: 'button' | 'menu';
  /** Target element for button shares */
  target?: any;
  /** Web page URL for sharing */
  webViewUrl?: string;
}

interface WechatMiniprogram.Page.Instance<TData> {
  /** Current page route */
  readonly route: string;
  
  /** Page load options */
  readonly options: Record<string, string>;
  
  /** Update page data and trigger re-render */
  setData(
    data: Partial<TData>,
    callback?: () => void
  ): void;
}

// Common scene values for app launch
enum WechatMiniprogram.App.SceneValues {
  /** Launch from chat session discovery */
  GROUP_CHAT_DISCOVERY = 1001,
  
  /** Launch from group chat */
  GROUP_CHAT = 1005,
  
  /** Launch from one-on-one chat */
  SINGLE_CHAT = 1006,
  
  /** Launch from WeChat scan */
  SCAN_QR_CODE = 1011,
  
  /** Launch from long press to identify QR code */
  LONG_PRESS_QR_CODE = 1012,
  
  /** Launch from app search */
  SEARCH = 1017,
  
  /** Launch from WeChat Moments */
  MOMENTS = 1020,
  
  /** Launch from nearby mini programs */
  NEARBY = 1023,
  
  /** Launch from profile page */
  PROFILE = 1024,
  
  /** Launch from system search */
  SYSTEM_SEARCH = 1025,
  
  /** Launch from tab bar */
  TAB_BAR = 1089,
  
  /** Launch from menu */
  MENU = 1090
}

namespace WechatMiniprogram.App {
  interface Instance<TData = any> {
    /** Global data shared across the app */
    globalData: TData;
  }
  
  interface DataOption {
    [key: string]: any;
  }
  
  interface Option<TData> extends Instance<TData> {
    [key: string]: any;
  }
}

namespace WechatMiniprogram.Page {
  interface Instance<TData = any> {
    readonly route: string;
    readonly options: Record<string, string>;
    setData(data: Partial<TData>, callback?: () => void): void;
  }
  
  interface DataOption {
    [key: string]: any;
  }
  
  interface Option<TData> {
    data?: TData;
    [key: string]: any;
  }
}