@await-widget/runtime 0.0.1

package/runtime/bridge.d.ts

@@ -0,0 +1,187 @@
+type AwaitNetworkResponse = {
+  code: number;
+  data: string;
+};
+export declare function setTimeout(
+  callback: (...args: unknown[]) => void,
+  ms: number,
+): unknown;
+export declare function clearTimeout(timerID: unknown): void;
+export declare function setInterval(
+  callback: (...args: unknown[]) => void,
+  ms: number,
+): unknown;
+export declare function sleep(ms: number): Promise<void>;
+export declare function clearInterval(timerID: unknown): void;
+export declare function print(...args: unknown[]): void;
+export declare const console: {
+  log(...args: unknown[]): void;
+};
+export declare const AwaitClipboard: {
+  set(value: string): void;
+};
+type AwaitNetworkConfig = {
+  method?: string;
+  headers?: Record<string, string>;
+  body?: Encodable;
+};
+type AwaitFoufouConfig = {
+  method?: string;
+  image?: string;
+  oauthToken?: string;
+  oauthTokenSecret?: string;
+  parameters?: Record<string, string | number | boolean>;
+};
+export declare const AwaitNetwork: {
+  request(
+    urlString: string,
+    config?: AwaitNetworkConfig,
+  ): Promise<AwaitNetworkResponse>;
+  fanfou(urlString: string, config?: AwaitFoufouConfig): Promise<unknown>;
+};
+export declare const AwaitWeather: {
+  get(config?: AwaitWeatherConfig): Promise<AwaitWeatherResult | undefined>;
+};
+export declare const AwaitHealth: {
+  get(): Promise<AwaitHealthInfo | undefined>;
+};
+export declare const AwaitLocation: {
+  get(config?: AwaitLocationConfig): Promise<AwaitLocationInfo | undefined>;
+};
+export declare const AwaitCalendar: {
+  get(config?: AwaitCalendarConfig): Promise<AwaitCalendarItem[] | undefined>;
+};
+export declare const AwaitReminder: {
+  get(config?: AwaitReminderConfig): Promise<AwaitReminderItem[] | undefined>;
+};
+export declare const AwaitSystem: {
+  get(): AwaitSystemInfo;
+};
+export declare const AwaitAlarm: {
+  schedule(config: AwaitAlarmScheduleConfig): Promise<string>;
+  cancel(id: string): any;
+};
+export declare const AwaitMedia: {
+  nowPlayingMedia(config?: AwaitNowPlayingConfig): Promise<AwaitNowPlayingInfo>;
+  mediaPlayerCommand(
+    command: AwaitMusicPlayerCommand,
+    config?: AwaitMediaPlayConfig,
+  ): Promise<void>;
+};
+export declare const AwaitStore: {
+  get<T>(key: string): T | undefined;
+  num(key: string, defaultValue?: number): number;
+  bool(key: string, defaultValue?: boolean): boolean;
+  string(key: string, defaultValue?: string): string;
+  array<T>(key: string, defaultValue?: T[]): T[];
+  delete(key: string): void;
+  set(key: string, value: Encodable): void;
+};
+export declare const AwaitFile: {
+  files(path: string): string[];
+  readJSON(path: string): unknown;
+  readText(path: string): string | undefined;
+  fileSize(path: string): number | undefined;
+  readTextByPage(
+    path: string,
+    page: number,
+    pageSize: number,
+  ): string | undefined;
+  readTextByPages(
+    path: string,
+    pages: number[],
+    pageSize: number,
+  ): Array<string | undefined>;
+  saveUIRenderImage(path: string, value: NativeView): void;
+};
+export declare const AwaitAudio: {
+  readonly isPlayingNote: boolean;
+  setAudioSession(active: boolean, option?: AudioOption): void;
+  reinstallInstruments(): void;
+  playAudio(url: string, config?: AudioConfig): void;
+  pauseAudio(): void;
+  playMidi(url: string, config?: AudioConfig): void;
+  stopMidi(): void;
+  replayMidi(config?: AudioConfig): void;
+  recordMidi(): void;
+  buildSoundFont(config: SoundFontBuildConfig): Promise<SoundFontBuildResult>;
+  compressSoundFont(
+    config: SoundFontCompressConfig,
+  ): Promise<SoundFontBuildResult>;
+  playNote(notes: number[] | number, config?: AudioConfig): void;
+};
+export declare const AwaitUI: {
+  readonly displayScale: number;
+  haptic(type: string): void;
+};
+type AwaitDefineConfig<Intents, T extends Record<string, unknown>> = {
+  widget: (entry: WidgetEntry<T>) => NativeView;
+  widgetTimeline?: (
+    context: TimelineContext,
+  ) => Timeline<T> | Promise<Timeline<T>>;
+  widgetIntents?: {
+    [IntentKey in keyof Intents]: Intents[IntentKey] extends (
+      ...args: infer IntentArguments
+    ) => void
+      ? IntentArguments extends Encodable[]
+        ? Intents[IntentKey]
+        : never
+      : never;
+  };
+};
+type AwaitDefineResult<Intents> = {
+  [IntentKey in keyof Intents]: Intents[IntentKey] extends (
+    ...args: infer IntentArguments
+  ) => void
+    ? (...args: IntentArguments) => IntentInfo
+    : never;
+};
+export declare const Await: {
+  define<Intents, T extends Record<string, unknown>>(
+    config: AwaitDefineConfig<Intents, T>,
+  ): AwaitDefineResult<Intents>;
+};
+export declare const AwaitEnv: {
+  readonly id: string;
+  readonly tag: number;
+  readonly host: "app" | "widget";
+  test(...args: unknown[]): unknown;
+};
+type AwaitGlobal = typeof Await;
+type AwaitEnvGlobal = typeof AwaitEnv;
+type AwaitUIGlobal = typeof AwaitUI;
+type AwaitClipboardGlobal = typeof AwaitClipboard;
+type AwaitNetworkGlobal = typeof AwaitNetwork;
+type AwaitWeatherGlobal = typeof AwaitWeather;
+type AwaitHealthGlobal = typeof AwaitHealth;
+type AwaitLocationGlobal = typeof AwaitLocation;
+type AwaitCalendarGlobal = typeof AwaitCalendar;
+type AwaitReminderGlobal = typeof AwaitReminder;
+type AwaitSystemGlobal = typeof AwaitSystem;
+type AwaitAlarmGlobal = typeof AwaitAlarm;
+type AwaitMediaGlobal = typeof AwaitMedia;
+type AwaitStoreGlobal = typeof AwaitStore;
+type AwaitFileGlobal = typeof AwaitFile;
+type AwaitAudioGlobal = typeof AwaitAudio;
+type SleepGlobal = typeof sleep;
+declare global {
+  const Await: AwaitGlobal;
+  const AwaitEnv: AwaitEnvGlobal;
+  const AwaitUI: AwaitUIGlobal;
+  const AwaitClipboard: AwaitClipboardGlobal;
+  const AwaitNetwork: AwaitNetworkGlobal;
+  const AwaitWeather: AwaitWeatherGlobal;
+  const AwaitHealth: AwaitHealthGlobal;
+  const AwaitLocation: AwaitLocationGlobal;
+  const AwaitCalendar: AwaitCalendarGlobal;
+  const AwaitReminder: AwaitReminderGlobal;
+  const AwaitSystem: AwaitSystemGlobal;
+  const AwaitAlarm: AwaitAlarmGlobal;
+  const AwaitMedia: AwaitMediaGlobal;
+  const AwaitStore: AwaitStoreGlobal;
+  const AwaitFile: AwaitFileGlobal;
+  const AwaitAudio: AwaitAudioGlobal;
+  function print(...args: unknown[]): void;
+  const sleep: SleepGlobal;
+}
+export {};

package/runtime/jsx-runtime.d.ts

@@ -0,0 +1 @@
+export { jsx, jsx as jsxs, Fragment } from "await";

package/types/global.d.ts

@@ -0,0 +1,281 @@
+type Encodable =
+  | string
+  | number
+  | boolean
+  | undefined
+  | Encodable[]
+  | { [key: string]: Encodable };
+type AudioOption = "mix" | "duckOthers" | "solo";
+type ColorScheme = "light" | "dark";
+type RenderingMode = "fullColor" | "accented" | "vibrant";
+type TemplateRenderingMode = "original" | "template";
+type Update = Date | "end" | "never";
+type WidgetFamily =
+  | "small"
+  | "medium"
+  | "large"
+  | "extraLarge"
+  | "extraLargePortrait"
+  | "accessoryInline"
+  | "accessoryCircular"
+  | "accessoryRectangular"
+  | "unknown";
+type Size = { width: number; height: number };
+
+type SingleNativeView =
+  | {
+      kind: string;
+      flat?: unknown[];
+      children?: NativeView;
+    }
+  | string
+  | number
+  | undefined;
+type NativeView = SingleNativeView | NativeView[];
+
+type IntentInfo = {
+  name: string;
+  args: Encodable[];
+};
+
+type AudioConfig = {
+  soundFont?: string;
+  volume?: number;
+  duration?: number;
+  delay?: number;
+  velocity?: number;
+  preset?: number;
+  bank?: number;
+  loop?: boolean;
+  audioOption?: AudioOption;
+};
+
+type SoundFontManualMapping = {
+  path: string;
+  key: number;
+};
+
+type SoundFontBuildConfig = {
+  savePath: string;
+  dataSizeLimitMB?: number;
+  mediaFiles?: string[];
+  mappings?: SoundFontManualMapping[];
+};
+
+type SoundFontCompressConfig = {
+  fromPath: string;
+  savePath: string;
+  dataSizeLimitMB?: number;
+};
+
+type SoundFontBuildResult = {
+  ok: true;
+  output: string;
+  resolvedOutput: string;
+  sizeBytes: number;
+};
+
+type AwaitWeatherConfig = {
+  latitude?: number;
+  longitude?: number;
+  hourlyLimit?: number;
+  dailyLimit?: number;
+};
+
+type AwaitWeatherCurrent = {
+  date: string;
+  condition: string;
+  symbolName: string;
+  temperatureCelsius: number;
+  apparentTemperatureCelsius: number;
+  humidity: number;
+  uvIndex: number;
+  windSpeedMetersPerSecond: number;
+  windDirectionDegrees: number;
+  pressureHectopascals: number;
+  visibilityKilometers: number;
+};
+
+type AwaitWeatherHourly = {
+  date: string;
+  condition: string;
+  symbolName: string;
+  temperatureCelsius: number;
+  humidity: number;
+  uvIndex: number;
+  windSpeedMetersPerSecond: number;
+  precipitationChance: number;
+};
+
+type AwaitWeatherDaily = {
+  date: string;
+  condition: string;
+  symbolName: string;
+  highTemperatureCelsius: number;
+  lowTemperatureCelsius: number;
+  precipitationChance: number;
+  uvIndex: number;
+};
+
+type AwaitWeatherResult = {
+  location: { latitude: number; longitude: number };
+  current: AwaitWeatherCurrent;
+  hourly: AwaitWeatherHourly[];
+  daily: AwaitWeatherDaily[];
+};
+
+type AwaitHealthInfo = {
+  stepCount?: number;
+  distanceWalkingRunning?: number;
+  flightsClimbed?: number;
+};
+
+type AwaitLocationConfig = {
+  desiredAccuracyMeters?: number;
+  timeoutSeconds?: number;
+};
+
+type AwaitLocationInfo = {
+  latitude: number;
+  longitude: number;
+  date: Date;
+  altitudeMeters?: number;
+  speedMetersPerSecond?: number;
+  courseDegrees?: number;
+};
+
+type AwaitNowPlayingConfig = {
+  artworkSize?: number;
+};
+
+type AwaitNowPlayingInfo = {
+  state?:
+    | "playing"
+    | "paused"
+    | "stopped"
+    | "interrupted"
+    | "seekingForward"
+    | "seekingBackward";
+  sourceConfig?: AwaitMediaPlayConfig;
+  id?: string;
+  title?: string;
+  artistName?: string;
+  albumTitle?: string;
+  artworkURL?: string;
+  maximumWidth?: number;
+  maximumHeight?: number;
+  backgroundColor?: Color;
+  primaryTextColor?: Color;
+  secondaryTextColor?: Color;
+  tertiaryTextColor?: Color;
+  quaternaryTextColor?: Color;
+};
+
+type AwaitMusicPlayerCommand = "start" | "toggle" | "next" | "previous";
+
+type AwaitMediaPlayConfig =
+  | {
+      source: "song";
+      id?: string;
+      query?: string;
+      limit?: number;
+      shuffle?: boolean;
+      loop?: boolean;
+      offset?: number;
+    }
+  | {
+      source: "album";
+      id?: string;
+      query?: string;
+      shuffle?: boolean;
+      loop?: boolean;
+    }
+  | {
+      source: "station";
+      query?: string;
+      type?: "discovery" | "user";
+      id?: string;
+    };
+
+type AwaitCalendarConfig = {
+  start?: Date;
+  end?: Date;
+  limit?: number;
+};
+
+type AwaitCalendarItem = {
+  calendarTitle: string;
+  title: string;
+  startDate: Date;
+  endDate: Date;
+  isAllDay: boolean;
+  location?: string;
+  notes?: string;
+  url?: string;
+};
+
+type AwaitReminderConfig = {
+  type?: "all" | "incomplete" | "completed";
+  limit?: number;
+};
+
+type AwaitReminderItem = {
+  calendarTitle: string;
+  title: string;
+  notes?: string;
+  isCompleted: boolean;
+  priority: number;
+  startDate?: Date;
+  dueDate?: Date;
+  completionDate?: Date;
+};
+
+type AwaitSystemInfo = {
+  battery: {
+    state: "charging" | "full" | "unplugged" | "unknown";
+    percent: number;
+    lowPowerMode: boolean;
+  };
+  memory?: {
+    used: number;
+    free: number;
+    total: number;
+    percent: number;
+  };
+  cpu: {
+    percent?: number;
+  };
+  storage?: {
+    total: number;
+    free: number;
+    used: number;
+    percent: number;
+  };
+};
+
+type AwaitAlarmScheduleConfig = {
+  title?: string;
+  duration?: number;
+  date?: Date;
+  tint?: Color;
+};
+
+type WidgetEntry<T extends Record<string, unknown> = Record<string, unknown>> =
+  {
+    colorScheme: ColorScheme;
+    renderingMode: RenderingMode;
+    size: Size;
+    family: WidgetFamily;
+  } & {
+    date: Date;
+  } & T;
+
+type TimelineContext = {
+  size: Size;
+  family: WidgetFamily;
+};
+
+type Timeline<T extends Record<string, unknown> = Record<string, unknown>> = {
+  entries: Array<{ date: Date } & T>;
+  update?: Update;
+};

package/types/jsx.d.ts

@@ -0,0 +1,4 @@
+declare namespace JSX {
+  type Element = NativeView;
+  type IntrinsicElements = never;
+}