Runtime Management

/**
 * Creates a Toutiao mini-program application
 * @param options - Application configuration options
 * @returns App instance with Toutiao-specific adaptations
 */
function createApp(options: AppOptions): App;

interface AppOptions {
  /** Called when the mini-program launches */
  onLaunch?: () => void;
  /** Called when the mini-program becomes visible */
  onShow?: () => void;
  /** Called when the mini-program becomes hidden */
  onHide?: () => void;
  /** Called when an uncaught error occurs */
  onError?: (error: string) => void;
  /** Additional app-level configuration */
  [key: string]: any;
}

import { createApp } from "@dcloudio/uni-mp-toutiao/runtime";

const app = createApp({
  onLaunch() {
    console.log('Toutiao Mini Program Started');
    // Initialize global data or configurations
  },
  onShow() {
    console.log('App became visible');
  },
  onHide() {
    console.log('App became hidden');
  },
  onError(error) {
    console.error('App error:', error);
  }
});

/**
 * Creates a mini-program page with Toutiao-specific lifecycle
 * @param options - Page configuration options
 * @returns Page instance with platform adaptations
 */
function createPage(options: PageOptions): Page;

interface PageOptions {
  /** Page data object */
  data?: Record<string, any>;
  /** Called when page loads with query parameters */
  onLoad?: (options: Record<string, any>) => void;
  /** Called when page becomes visible */
  onShow?: () => void;
  /** Called when page is ready for interaction */
  onReady?: () => void;
  /** Called when page becomes hidden */
  onHide?: () => void;
  /** Called when page is unloaded */
  onUnload?: () => void;
  /** Called when page is pulled down to refresh */
  onPullDownRefresh?: () => void;
  /** Called when page reaches bottom */
  onReachBottom?: () => void;
  /** Additional page methods and properties */
  [key: string]: any;
}

import { createPage } from "@dcloudio/uni-mp-toutiao/runtime";

const pageOptions = createPage({
  data: {
    userInfo: null,
    loading: false
  },
  onLoad(query) {
    console.log('Page loaded with:', query);
    this.loadUserData();
  },
  onShow() {
    console.log('Page shown');
  },
  onReady() {
    console.log('Page ready for interaction');
  },
  loadUserData() {
    this.setData({ loading: true });
    // Load user data...
  }
});

/**
 * Creates a mini-program component with Toutiao-specific behavior
 * @param options - Component configuration options
 * @returns Component instance with platform adaptations
 */
function createComponent(options: ComponentOptions): Component;

interface ComponentOptions {
  /** Component data object */
  data?: Record<string, any>;
  /** Component properties definition */
  props?: Record<string, PropDefinition>;
  /** Called when component is attached to DOM */
  attached?: () => void;
  /** Called when component is ready for interaction */
  ready?: () => void;
  /** Called when component is detached from DOM */
  detached?: () => void;
  /** Component relationship definitions */
  relations?: Record<string, RelationDefinition>;
  /** Custom component methods */
  methods?: Record<string, (...args: any[]) => any>;
  /** Additional component configuration */
  [key: string]: any;
}

interface PropDefinition {
  type: any;
  value?: any;
  observer?: (newVal: any, oldVal: any, changedPath: string) => void;
}

interface RelationDefinition {
  type: 'parent' | 'child' | 'ancestor' | 'descendant';
  target: string;
  linked?: (target: any) => void;
  linkChanged?: (target: any) => void;
  unlinked?: (target: any) => void;
}

import { createComponent } from "@dcloudio/uni-mp-toutiao/runtime";

const componentOptions = createComponent({
  data: {
    count: 0,
    visible: true
  },
  props: {
    title: {
      type: String,
      value: 'Default Title',
      observer(newVal, oldVal) {
        console.log('Title changed:', newVal);
      }
    },
    initialCount: {
      type: Number,
      value: 0
    }
  },
  attached() {
    console.log('Component attached');
    this.setData({ count: this.properties.initialCount });
  },
  ready() {
    console.log('Component ready');
  },
  detached() {
    console.log('Component detached');
  },
  relations: {
    './parent-component': {
      type: 'parent',
      linked(target) {
        console.log('Linked to parent:', target);
      }
    }
  },
  methods: {
    increment() {
      this.setData({ count: this.data.count + 1 });
      this.triggerEvent('countChanged', { count: this.data.count });
    }
  }
});

/**
 * Creates a subpackage application
 * @param options - Subpackage application options
 * @returns SubpackageApp instance
 */
function createSubpackageApp(options: SubpackageAppOptions): SubpackageApp;

interface SubpackageAppOptions {
  /** Subpackage launch handler */
  onLaunch?: () => void;
  /** Subpackage show handler */
  onShow?: () => void;
  /** Subpackage hide handler */
  onHide?: () => void;
  /** Additional subpackage configuration */
  [key: string]: any;
}

import { createSubpackageApp } from "@dcloudio/uni-mp-toutiao/runtime";

const subpackageApp = createSubpackageApp({
  onLaunch() {
    console.log('Subpackage launched');
  },
  onShow() {
    console.log('Subpackage shown');
  },
  onHide() {
    console.log('Subpackage hidden');
  }
});

class EventChannel {
  /** Emit an event to all listeners */
  emit(eventName: string, ...args: any[]): void;
  /** Listen for events */
  on(eventName: string, callback: (...args: any[]) => void): void;
  /** Remove event listeners */
  off(eventName: string, callback?: (...args: any[]) => void): void;
  /** Listen for events once only */
  once(eventName: string, callback: (...args: any[]) => void): void;
}