@moddable/typings 7.1.0 → 7.2.1

package/piu/MC.d.ts

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2025 Shinya Ishikawa
+ * Copyright (c) 2020-2026 Shinya Ishikawa
  *
  *   This file is part of the Moddable SDK Tools.
  *
@@ -20,557 +20,35 @@
 
 declare module "piu/MC" {
   import {} from "commodetto/Poco";   // for global screen
-
-  /* type aliases */
-  type Coordinates = {
-    top?: number;
-    right?: number;
-    bottom?: number;
-    left?: number;
-  };
-  type Position = {
-    x?: number;
-    y?: number;
-  };
-  type Size = {
-    width?: number;
-    height?: number;
-  };
-  type Bounds = Position & Size;
-  type Color = string;
-  type ContentState = {
-    state?: number;
-    variant?: number;
-  };
-  type TimeProperty = {
-    time?: number;
-    duration?: number;
-    fraction?: number;
-    interval?: number;
-    loop?: boolean;
-  };
-  type TouchProperty = {
-    active?: boolean;
-    backgroundTouch?: boolean;
-    exclusiveTouch?: boolean;
-    multipleTouch?: boolean;
-  };
-
-  // TODO: more accurate constructor parameters
-  type TemplateStyle<P, C extends new (...args: any) => any> = {
-    new (dictionary?: P): InstanceType<C>;
-    template: TemplateStyleFactory<C>;
-  };
-  type TemplateStyleFactory<T extends new (...args: any) => any> = (
-    param: ConstructorParameters<T>[0]
-  ) => TemplateStyle<Partial<ConstructorParameters<T>[1]>, T>;
-
-  type TemplateComponent<P, C extends new (...args: any) => any> = {
-    new (behaviorData?: any, dictionary?: P): InstanceType<C>;
-    template: TemplateComponentFactory<C>;
-  };
-  type TemplateComponentFactory<T extends new (...args: any) => any> = (
-    func: (param: any) => ConstructorParameters<T>[1]
-  ) => TemplateComponent<Parameters<typeof func>[0], T>;
-
-  interface Behavior<T extends Content = Content>{
-    onCreate?(content: T, data: object, context: any): void;
-    onDisplaying?(content: T): void;
-    onFinished?(content: T): void;
-    onTimeChanged?(content: T): void;
-    onTouchBegan?(content: T, id: number, x: number, y: number, ticks: number): void;
-    onTouchCancelled?(content: T, id: number): void;
-    onTouchended?( content: T, id: number, x: number, y: number, ticks: number): void;
-    onTouchMoved?( content: T, id: number, x: number, y: number, ticks: number): void;
-    // TODO: complete callbacks
-  }
-
-interface BehaviorConstructor<T extends Content = Content> {
-  new(): Behavior<T>;
-}
-
-  interface Content {
-    // TODO: consider type parameter to avoid any
-    adjust(x: number, y: number): void;
-    bubble(id: string, ...extras: any[]): void;
-    captureTouch(id: string, x: number, y: number, ticks: number): void;
-    defer(id: string, ...extras: any[]): void;
-    delegate(id: string, ...extras: any[]): void;
-    distribute(id: string, ...extras: any[]): void;
-    focus(): void;
-    hit(x: number, y: number): Content | undefined;
-    measure(): Size;
-    moveBy(x: number, y: number): void;
-    render(): void;
-    sizeBy(width: number, height: number): void;
-    start(): void;
-    stop(): void;
-
-    readonly previous: Content | null;
-    readonly next: Content | null;
-    readonly container: Container | null;
-    readonly index: number;
-    name: string;
-    active: boolean;
-    anchor: string;
-    behavior: object;
-    coordinates: Coordinates;
-    bounds: Bounds;
-    backgroundTouch: boolean;
-    exclusiveTouch: boolean;
-    multipleTouch: boolean;
-
-    time: number;
-    duration: number;
-    fraction: number;
-    interval: number;
-    loop: boolean;
-    running: boolean;
-    offset: undefined | Position;
-    position: undefined | Position;
-    size: Size;
-    state: number;
-    variant: number;
-    skin: Skin | null;
-    style: Style | null;
-    visible: boolean;
-    x: number;
-    y: number;
-    width: number;
-    height: number;
-  }
-  interface ContentDictionary
-    extends Coordinates,
-      Size,
-      ContentState,
-      TimeProperty,
-      TouchProperty {
-    name?: string;
-    anchor?: string;
-    Behavior?: BehaviorConstructor;
-    skin?: Skin | SkinDictionary;
-    Skin?: SkinConstructor;
-    style?: Style | StyleDictionary;
-    Style?: StyleConstructor;
-    visible?: boolean;
-  }
-  interface ContentConstructor {
-    new(behaviorData?: any, dictionary?: ContentDictionary): Content;
-    (behaviorData?: any, dictionary?: ContentDictionary): Content;
-    readonly prototype: Content;
-
-    template: TemplateComponentFactory<typeof Content>;
-  }
-
-  interface Style {
-    measure(string: string): Size;
-  }
-  interface StyleDictionaryBase {
-    color?: Color | Color[];
-    font?: string;
-    horizontal?: string;
-    top?: number;
-  }
-  interface StyleConstructor {
-    new(dictionary: StyleDictionary): Style;
-
-    template<T>(this: T, dictionary: StyleDictionary): T;
-  }
-  
-  interface TextStyleDictionary extends StyleDictionaryBase {
-    leading?: number;
-    right?: number;
-    bottom?: number;
-    left?: number;
-  }
-  interface LabelStyleDictionary extends StyleDictionaryBase {
-    vertical?: string;
-  }
-  type StyleDictionary = LabelStyleDictionary | TextStyleDictionary;
-
-  interface Texture {
-    readonly height: number;
-    readonly width: number;
-  }
-  interface TextureDictionary {
-    path: string;
-  }
-  interface TextureConstructor {
-    new(path: string): Texture;
-    new(dictionary: TextureDictionary): Texture;
-    readonly prototype: Texture;
-
-    template: TemplateStyleFactory<typeof Texture>;
-  }
-
-  interface Skin {
-    borders: Coordinates;
-    fill: Color | Color[];
-    stroke: Color | Color[];
-    texture: Texture;
-    color: Color;
-    bounds: Bounds;
-    height: number;
-    width: number;
-    states?: number;
-    variants?: number;
-    tiles?: Coordinates;
-    top?: number;
-    right?: number;
-    bottom?: number;
-    left?: number;
-  }
-  interface SkinConstructor {
-    new(dictionary: SkinDictionary): Skin;
-    readonly prototype: Skin;
-
-    template: TemplateStyleFactory<typeof Skin>;
-  }
-
-  interface TextureSkinDictionary extends Coordinates, Bounds {
-    texture?: Texture | TextureDictionary;
-    Texture?: TextureConstructor;
-    color?: Color | Color[];
-    states?: number;
-    variants?: number;
-    tiles?: Coordinates;
-  }
-  interface ColorSkinDictionary {
-    borders?: Coordinates;
-    fill?: Color | Color[];
-    stroke?: Color | Color[];
-  }
-  type SkinDictionary = ColorSkinDictionary | TextureSkinDictionary;
-
-  interface Transition {
-    onBegin(container: Container, ...extras: any[]): void;
-    onEnd(container: Container, ...extras: any[]): void;
-    onStep(fraction: number): void;
-    duration?: number;
-  }
-  interface TransitionConstructor {
-    new(duration: number, interpolator?: (value: number) => number, first?: any, last?: any): Transition
-  }
-
-  interface Container extends Content {
-    clip: boolean;
-    readonly first: Content | null;
-    readonly last: Content | null;
-    readonly length: number;
-    readonly transitioning: boolean;
-    add(content: Content): void;
-    content(at: number | string): Content | undefined;
-    empty(start?: number, stop?: number): void;
-    firstThat(id: string, ...extras: any[]): void;
-    insert(content: Content, before: Content): void;
-    lastThat(id: string, ...extras: any[]): void;
-    remove(content: Content): void;
-    replace(content: Content, by: Content): void;
-    run(transition: Transition, ...extras: any[]): void;
-    swap(content0: Content, content1: Content): void;
-    onTransitionBeginning(container: Container): void;
-    onTransitionEnded(container: Container): void;
-  }
-  interface ContainerDictionary extends ContentDictionary {
-    clip?: boolean;
-    contents?: Content[];
-  }
-  interface ContainerConstructor {
-    new(behaviorData?: any, dictionary?: ContainerDictionary): Container;
-    (behaviorData?: any, dictionary?: ContainerDictionary): Container;
-
-    template<T>(this: T, fn: (arg: any) => ContainerDictionary): T;
-  }
-
-  interface Label extends Content {
-    string: string;
-  }
-  interface LabelDictionary extends ContentDictionary {
-    string?: string;
-  }
-  interface LabelConstructor {
-    new(behaviorData?: any, dictionary?: LabelDictionary): Label;
-    (behaviorData?: any, dictionary?: LabelDictionary): Label;
-
-    template<T>(this: T, fn: (arg: any) => LabelDictionary): T;
-  }
-
-  interface Port extends Content {
-    drawContent(
-      x: number,
-      y: number,
-      width: number,
-      height: number
-    ): void;
-    drawLabel(
-      string: string,
-      x: number,
-      y: number,
-      width: number,
-      height: number
-    ): void;
-    drawSkin(
-      skin: Skin,
-      x: number,
-      y: number,
-      width: number,
-      height: number,
-      variant?: number,
-      state?: number
-    ): void;
-    drawString(
-      string: string,
-      style: Style,
-      color: Color,
-      x: number,
-      y: number,
-      width: number,
-      height: number
-    ): void;
-    drawStyle(
-      string: string,
-      style: Style,
-      x: number,
-      y: number,
-      width: number,
-      height: number,
-      ellipsis?: boolean,
-      state?: number
-    ): void;
-    drawTexture(
-      texture: Texture,
-      color: Color,
-      x: number,
-      y: number,
-      sx: number,
-      sy: number,
-      sw: number,
-      sh: number
-    ): void;
-    fillColor(
-      color: Color,
-      x: number,
-      y: number,
-      width: number,
-      height: number
-    ): void;
-    fillTexture(
-      texture: Texture,
-      color: Color,
-      x: number,
-      y: number,
-      width: number,
-      height: number,
-      sx?: number,
-      sy?: number,
-      sw?: number,
-      sh?: number
-    ): void;
-    invalidate(
-      x?: number,
-      y?: number,
-      width?: number,
-      height?: number
-    ): void;
-    measureString(string: string, style: Style): Size;
-    popClip(): void;
-    pushClip(
-      x?: number,
-      y?: number,
-      width?: number,
-      height?: number
-    ): void;
-    onDraw(
-      port: Port,
-      x: number,
-      y: number,
-      width: number,
-      height: number
-    ): void;
-  }
-  interface PortConstructor extends ContentConstructor {
-  }
-
-  interface TextBlock {
-      behavior?: object | null;
-      style?: Style | null;
-      spans: (string | TextSpan)[] | string,
-  }
-
-  interface TextSpan extends TextBlock {
-      link?: any
-  }
-
-  interface Text extends Content {
-    blocks: TextBlock[],
-    string: string;
-    begin(): void;
-    beginBlock(style?: Style, behavior?: object): void;
-    beginSpan(style: Style, behavior?: object): void;
-    concat(string: string): void;
-    end(): void;
-    endBlock(): void;
-    endSpan(): void;
-  }
-  interface TextDictionary extends ContentDictionary {
-    blocks?: TextBlock[],
-    string?: string;
-  }
-  interface TextConstructor {
-    new(behaviorData?: any, dictionary?: TextDictionary): Text;
-    (behaviorData?: any, dictionary?: TextDictionary): Text;
-
-    template<T>(this: T, fn: (arg: any) => TextDictionary): T;
-  }
-
-  interface Application extends Container {
-    displayListLength: number;
-    commandListLength: number;
-    touchCount: number;
-  }
-  interface ApplicationDictionary extends ContainerDictionary {
-    displayListLength?: number;
-    commandListLength?: number;
-    touchCount?: number;
-    pixels?: number;
-  }
-  interface ApplicationConstructor {
-    new(behaviorData?: any, dictionary?: ApplicationDictionary): Application;
-
-    template<T>(this: T, fn: (arg: any) => ApplicationDictionary): T;
-  }
-
-  interface Column extends Container {
-  }
-  interface ColumnConstructor extends ContainerConstructor {
-  }
-
-  interface Layout extends Container {
-    onFitHorizontally(layout: Layout, width: number): void;
-    onFitVertically(layout: Layout, height: number): void;
-    onMeasureHorizontally(layout: Layout, width: number): void;
-    onMeasureVertically(layout: Layout, height: number): void;
-  }
-  interface LayoutConstructor extends ContainerConstructor {
-  }
-
-  interface Image extends Content {
-    readonly frameCount: never;
-    frameIndex: number;
-  }
-  interface ImageDictionary extends ContentDictionary {
-    path: string;
-  }
-  interface ImageConstructor {
-    new(behaviorData?: any, dictionary?: ImageDictionary): Image;
-    (behaviorData?: any, dictionary?: ImageDictionary): Image;
-
-    template<T>(this: T, fn: (arg: any) => ImageDictionary): T;
-  }
-
-  interface Die extends Layout {
-    set(x: number, y: number, width: number, height: number): Die;
-    sub(x: number, y: number, width: number, height: number): Die;
-    and(x: number, y: number, width: number, height: number): Die;
-    or(x: number, y: number, width: number, height: number): Die;
-    xor(x: number, y: number, width: number, height: number): Die;
-    fill(): Die;
-    empty(): Die;
-    cut(): void;
-    attach(content: Content): void;
-    detach(): void;
-  }
-  interface DieConstructor extends LayoutConstructor {
-  }
-
-  interface Row extends Container {
-  }
-  interface RowConstructor extends ContainerConstructor {
-  }
-
-  interface Scroller extends Container {
-    readonly constraint: Position;
-    loop: boolean;
-    scroll: Position;
-    tracking: boolean;
-    reveal(bounds: Bounds): void;
-    scrollBy(dx: number, dy: number): void;
-    scrollTo(x: number, y: number): void;
-    onScrolled(scroller: Scroller): void;
-  }
-  interface ScrollerDictionary extends ContainerDictionary {
-    loop?: boolean;
-  }
-  interface ScrollerConstructor {
-    new(behaviorData?: any, dictionary?: ScrollerDictionary): Scroller;
-    (behaviorData?: any, dictionary?: ScrollerDictionary): Scroller;
-
-    template<T>(this: T, fn: (arg: any) => ScrollerDictionary): T;
-  }
-
-  interface LinkDictionary {
-    Behavior?: BehaviorConstructor;
-  }
-  interface Link {
-    readonly container: Container;
-    state: number;
-    captureTouch(id: number, x: number, y: number, ticks: number): void;
-  }
-  interface LinkConstructor {
-    new(behaviorData?: any, dictionary?: LinkDictionary): Link;
-    (behaviorData?: any, dictionary?: LinkDictionary): Link;
-
-    template<T>(this: T, fn: (arg: any) => LinkDictionary): T;
-  }
-
-  interface Locals {
-    new(name?: string, language?: string): Locals
-    language: string;
-    get(textToLocalize: string): string
-  }
-
-  interface blendColors {
-    (a: number, c1: number, c2: number): Color
-  }
-  interface hsl {
-    (h: number, s: number, l: number): Color
-  }
-  interface hsla {
-    (h: number, s: number, l: number, a: number): Color
-  }
-  interface rgb {
-    (r: number, g: number, b: number): Color
-  }
-  interface rgba {
-    (r: number, g: number, b: number, a: number): Color
-  }
-
+  import type * as MC from "piu/MC-types";
 
   global {
-    const Skin: SkinConstructor
-    const Texture: TextureConstructor
-    const Style: StyleConstructor
-    const Behavior: BehaviorConstructor
-    const Content: ContentConstructor
-    const Container: ContainerConstructor
-    const Application: ApplicationConstructor
-    const Scroller: ScrollerConstructor
-    const Row: RowConstructor
-    const Column: ColumnConstructor
-    const Layout: LayoutConstructor
-    const Image: ImageConstructor
-    const Die: DieConstructor
-    const Port: PortConstructor
-    const Label: LabelConstructor
-    const Transition: TransitionConstructor
-    const Text: TextConstructor
-    const Link: LinkConstructor
-    const application: Application
-    const Locals: Locals
-    const blendColors: blendColors
-    const hsl: hsl
-    const hsla: hsla
-    const rgb: rgb
-    const rgba: rgba
-  }
- }
+    const Skin: MC.SkinConstructor
+    const Texture: MC.TextureConstructor
+    const Style: MC.StyleConstructor
+    const Behavior: MC.BehaviorConstructor
+    const Content: MC.ContentConstructor
+    const Container: MC.ContainerConstructor
+    const Application: MC.ApplicationConstructor
+    const Scroller: MC.ScrollerConstructor
+    const Row: MC.RowConstructor
+    const Column: MC.ColumnConstructor
+    const Layout: MC.LayoutConstructor
+    const Image: MC.ImageConstructor
+    const Die: MC.DieConstructor
+    const Port: MC.PortConstructor
+    const Label: MC.LabelConstructor
+    const Transition: MC.TransitionConstructor
+    const Text: MC.TextConstructor
+    const Link: MC.LinkConstructor
+    const application: MC.Application
+    const Locals: MC.Locals
+    const blendColors: MC.blendColors
+    const hsl: MC.hsl
+    const hsla: MC.hsla
+    const rgb: MC.rgb
+    const rgba: MC.rgba
+  }
+
+  export * from "piu/MC-types";
+}

package/qrcode.d.ts

@@ -1,5 +1,5 @@
 /*
-* Copyright (c) 2024 Satoshi Tanaka
+* Copyright (c) 2024-2026 Satoshi Tanaka
 *
 *   This file is part of the Moddable SDK Tools.
 *
@@ -23,9 +23,11 @@ declare module "qrcode" {
         size: number;
     }
 
-    var qrCode: (options: {
+    const qrCode: (options: {
         input: string | ByteBuffer,
-        maxVersion?: number
+        maxVersion?: number,
+        bitmap?: number | boolean,
+        fit?: number,
     }) => qrcode;
 
     export { qrCode as default };

package/web/fetch.d.ts

@@ -0,0 +1,48 @@
+/*
+* Copyright (c) 2025-2026 Moddable Tech, Inc.
+*
+*   This file is part of the Moddable SDK Tools.
+*
+*   The Moddable SDK Tools is free software: you can redistribute it and/or modify
+*   it under the terms of the GNU General Public License as published by
+*   the Free Software Foundation, either version 3 of the License, or
+*   (at your option) any later version.
+*
+*   The Moddable SDK Tools is distributed in the hope that it will be useful,
+*   but WITHOUT ANY WARRANTY; without even the implied warranty of
+*   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*   GNU General Public License for more details.
+*
+*   You should have received a copy of the GNU General Public License
+*   along with the Moddable SDK Tools.  If not, see <http://www.gnu.org/licenses/>.
+*
+*/
+
+declare module "fetch" {
+  import {URL, URLSearchParams} from "url"
+  import Headers from "headers"
+
+  class Response {
+    get bodyUsed(): boolean;
+    get headers(): Headers;
+    get ok(): boolean;
+    get redirected(): boolean;
+    get status(): number;
+    get statusText(): string;
+    get url(): string;
+    arrayBuffer(): Promise<ArrayBuffer>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+  }
+
+  interface RequestInit {
+    method?: string;
+    headers?: Headers | Record<string, string>;
+    body?: string | ByteBuffer | URLSearchParams;
+  }
+
+  function fetch(resource: string | URL, options?: RequestInit): Promise<Response>;
+
+  export { fetch };
+  export default fetch;
+}

package/{url.d.ts → web/url.d.ts}

@@ -39,7 +39,7 @@ declare module "url" {
     }
 
     class URLSearchParams implements Iterable<[string, string]>{
-        constructor(it?: string[][] | Record<string, string> | string)
+        constructor(it?: string[][] | Record<string, { toString(): string }> | string)
         readonly length: number;
         append(name: string, value: string): void;
         delete(name: string, value?: string): void;