warpo 2.4.0 → 2.5.0-alpha-2

package/types/std/index.d.ts

@@ -112,8 +112,6 @@ declare const ASC_FEATURE_NONTRAPPING_F2I: bool;
 declare const ASC_FEATURE_BULK_MEMORY: bool;
 /** Whether the SIMD feature is enabled. */
 declare const ASC_FEATURE_SIMD: bool;
-/** Whether the threads feature is enabled. */
-declare const ASC_FEATURE_THREADS: bool;
 /** Whether the exception handling feature is enabled. */
 declare const ASC_FEATURE_EXCEPTION_HANDLING: bool;
 /** Whether the tail calls feature is enabled. */
@@ -283,44 +281,6 @@ declare function decodeURI(str: string): string;
 /** Decodes a Uniform Resource Identifier (URI) component previously created by encodeURIComponent. */
 declare function decodeURIComponent(str: string): string;
 
-/** Atomic operations. */
-declare namespace atomic {
-  /** Atomically loads an integer value from memory and returns it. */
-  export function load<T>(ptr: usize, immOffset?: usize): T;
-  /** Atomically stores an integer value to memory. */
-  export function store<T>(ptr: usize, value: T, immOffset?: usize): void;
-  /** Atomically adds an integer value in memory. */
-  export function add<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically subtracts an integer value in memory. */
-  export function sub<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically performs a bitwise AND operation on an integer value in memory. */
-  export function and<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically performs a bitwise OR operation on an integer value in memory. */
-  export function or<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically performs a bitwise XOR operation on an integer value in memory. */
-  export function xor<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically exchanges an integer value in memory. */
-  export function xchg<T>(ptr: usize, value: T, immOffset?: usize): T;
-  /** Atomically compares and exchanges an integer value in memory if the condition is met. */
-  export function cmpxchg<T>(ptr: usize, expected: T, replacement: T, immOffset?: usize): T;
-  /** Performs a wait operation on an address in memory suspending this agent if the integer condition is met. */
-  export function wait<T>(ptr: usize, expected: T, timeout?: i64): AtomicWaitResult;
-  /** Performs a notify operation on an address in memory waking up suspended agents. */
-  export function notify(ptr: usize, count?: i32): i32;
-  /** Performs a fence operation, preserving synchronization guarantees of higher level languages. */
-  export function fence(): void;
-}
-
-/** Describes the result of an atomic wait operation. */
-declare enum AtomicWaitResult {
-  /** Woken by another agent. */
-  OK,
-  /** Loaded value did not match the expected value. */
-  NOT_EQUAL,
-  /** Not woken before the timeout expired. */
-  TIMED_OUT,
-}
-
 /** Converts any other numeric value to an 8-bit signed integer. */
 declare function i8(value: any): i8;
 declare namespace i8 {
@@ -396,73 +356,6 @@ declare namespace i32 {
   export function rem_s(left: i32, right: i32): i32;
   /** Computes the unsigned remainder of two 32-bit integers. */
   export function rem_u(left: u32, right: u32): u32;
-
-  /** Atomic 32-bit integer operations. */
-  export namespace atomic {
-    /** Atomically loads an 8-bit unsigned integer value from memory and returns it as a 32-bit integer. */
-    export function load8_u(ptr: usize, immOffset?: usize): i32;
-    /** Atomically loads a 16-bit unsigned integer value from memory and returns it as a 32-bit integer. */
-    export function load16_u(ptr: usize, immOffset?: usize): i32;
-    /** Atomically loads a 32-bit integer value from memory and returns it. */
-    export function load(ptr: usize, immOffset?: usize): i32;
-    /** Atomically stores a 32-bit integer value to memory as an 8-bit integer. */
-    export function store8(ptr: usize, value: i32, immOffset?: usize): void;
-    /** Atomically stores a 32-bit integer value to memory as a 16-bit integer. */
-    export function store16(ptr: usize, value: i32, immOffset?: usize): void;
-    /** Atomically stores a 32-bit integer value to memory. */
-    export function store(ptr: usize, value: i32, immOffset?: usize): void;
-    /** Atomic 32-bit integer read-modify-write operations on 8-bit values. */
-    export namespace rmw8 {
-      /** Atomically adds an 8-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically subtracts an 8-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise AND operation an 8-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise OR operation an 8-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise XOR operation an 8-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically exchanges an 8-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically compares and exchanges an 8-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
-    }
-    /** Atomic 32-bit integer read-modify-write operations on 16-bit values. */
-    export namespace rmw16 {
-      /** Atomically adds a 16-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically adds a 16-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise AND operation a 16-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise OR operation a 16-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise XOR operation a 16-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically exchanges a 16-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically compares and exchanges a 16-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
-    }
-    /** Atomic 32-bit integer read-modify-write operations. */
-    export namespace rmw {
-      /** Atomically adds a 32-bit integer value in memory. */
-      export function add(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically subtracts a 32-bit integer value in memory. */
-      export function sub(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise AND operation a 32-bit integer value in memory. */
-      export function and(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise OR operation a 32-bit integer value in memory. */
-      export function or(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically performs a bitwise XOR operation a 32-bit integer value in memory. */
-      export function xor(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically exchanges a 32-bit integer value in memory. */
-      export function xchg(ptr: usize, value: i32, immOffset?: usize): i32;
-      /** Atomically compares and exchanges a 32-bit integer value in memory if the condition is met. */
-      export function cmpxchg(ptr: usize, expected: i32, replacement: i32, immOffset?: usize): i32;
-    }
-  }
 }
 /** Converts any other numeric value to a 64-bit signed integer. */
 declare function i64(value: any): i64;
@@ -525,94 +418,6 @@ declare namespace i64 {
   export function rem_s(left: i64, right: i64): i64;
   /** Computes the unsigned remainder of two 64-bit integers. */
   export function rem_u(left: u64, right: u64): u64;
-
-  /** Atomic 64-bit integer operations. */
-  export namespace atomic {
-    /** Atomically loads an 8-bit unsigned integer value from memory and returns it as a 64-bit integer. */
-    export function load8_u(ptr: usize, immOffset?: usize): i64;
-    /** Atomically loads a 16-bit unsigned integer value from memory and returns it as a 64-bit integer. */
-    export function load16_u(ptr: usize, immOffset?: usize): i64;
-    /** Atomically loads a 32-bit unsigned integer value from memory and returns it as a 64-bit integer. */
-    export function load32_u(ptr: usize, immOffset?: usize): i64;
-    /** Atomically loads a 64-bit integer value from memory and returns it. */
-    export function load(ptr: usize, immOffset?: usize): i64;
-    /** Atomically stores a 64-bit integer value to memory as an 8-bit integer. */
-    export function store8(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomically stores a 64-bit integer value to memory as a 16-bit integer. */
-    export function store16(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomically stores a 64-bit integer value to memory as a 32-bit integer. */
-    export function store32(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomically stores a 64-bit integer value to memory. */
-    export function store(ptr: usize, value: i64, immOffset?: usize): void;
-    /** Atomic 64-bit integer read-modify-write operations on 8-bit values. */
-    export namespace rmw8 {
-      /** Atomically adds an 8-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts an 8-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on an 8-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on an 8-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on an 8-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges an 8-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges an 8-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-    /** Atomic 64-bit integer read-modify-write operations on 16-bit values. */
-    export namespace rmw16 {
-      /** Atomically adds a 16-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts a 16-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on a 16-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on a 16-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on a 16-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges a 16-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges a 16-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-    /** Atomic 64-bit integer read-modify-write operations on 32-bit values. */
-    export namespace rmw32 {
-      /** Atomically adds a 32-bit unsigned integer value in memory. */
-      export function add_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts a 32-bit unsigned integer value in memory. */
-      export function sub_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on a 32-bit unsigned integer value in memory. */
-      export function and_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on a 32-bit unsigned integer value in memory. */
-      export function or_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on a 32-bit unsigned integer value in memory. */
-      export function xor_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges a 32-bit unsigned integer value in memory. */
-      export function xchg_u(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges a 32-bit unsigned integer value in memory if the condition is met. */
-      export function cmpxchg_u(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-    /** Atomic 64-bit integer read-modify-write operations. */
-    export namespace rmw {
-      /** Atomically adds a 64-bit integer value in memory. */
-      export function add(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically subtracts a 64-bit integer value in memory. */
-      export function sub(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise AND operation on a 64-bit integer value in memory. */
-      export function and(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise OR operation on a 64-bit integer value in memory. */
-      export function or(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically performs a bitwise XOR operation on a 64-bit integer value in memory. */
-      export function xor(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically exchanges a 64-bit integer value in memory. */
-      export function xchg(ptr: usize, value: i64, immOffset?: usize): i64;
-      /** Atomically compares and exchanges a 64-bit integer value in memory if the condition is met. */
-      export function cmpxchg(ptr: usize, expected: i64, replacement: i64, immOffset?: usize): i64;
-    }
-  }
 }
 /** Converts any other numeric value to a 32-bit signed integer. */
 declare let isize: typeof i32;
@@ -1716,6 +1521,10 @@ declare namespace f64x2 {
   export function relaxed_max(a: v128, b: v128): v128;
 }
 
+declare namespace ffi {
+  function set_ffi_closure_env(value: i32): void;
+}
+
 declare abstract class i31 {
   /** Creates a new 31-bit integer reference from the specified integer value. */
   static new(value: i32): ref_i31;
@@ -1853,13 +1662,6 @@ declare namespace memory {
   export function data(size: i32, align?: i32): usize;
   /** Gets a pointer to a pre-initialized static chunk of memory. Alignment defaults to the size of `T`. Arguments must be compile-time constants. */
   export function data<T>(values: T[], align?: i32): usize;
-
-  export namespace atomic {
-    /** Performs a wait operation on a 32-bit integer value in memory suspending this agent if the condition is met. */
-    export function wait32(ptr: usize, expected: i32, timeout?: i64): AtomicWaitResult;
-    /** Performs a wait operation on a 64-bit integer value in memory suspending this agent if the condition is met. */
-    export function wait64(ptr: usize, expected: i64, timeout?: i64): AtomicWaitResult;
-  }
 }
 
 /** Heap memory interface. */
@@ -1882,63 +1684,6 @@ declare namespace table {
   export function copy(dest: u32, src: u32, n: u32): void;
 }
 
-declare namespace Atomics {
-  export function load<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(array: TypedArray<T>, index: i32): T;
-  export function store<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): void;
-  export function add<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function sub<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function and<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function or<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function xor<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function exchange<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    value: T
-  ): T;
-  export function compareExchange<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    expectedValue: T,
-    replacementValue: T
-  ): T;
-  export function wait<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    value: T,
-    timeout?: i64
-  ): AtomicWaitResult;
-  export function notify<T extends i8 | u8 | i16 | u16 | i32 | u32 | i64 | u64>(
-    array: TypedArray<T>,
-    index: i32,
-    count?: i32
-  ): i32;
-  /** The static Atomics.isLockFree() method is used to determine whether to use locks or atomic operations. It returns true, if the given size is one of the BYTES_PER_ELEMENT */
-  export function isLockFree(size: usize): bool;
-}
-
 /** Class representing a generic, fixed-length raw binary data buffer. */
 declare class ArrayBuffer {
   /** The size, in bytes, of the array. */
@@ -2253,12 +1998,12 @@ declare class String implements Iterable<string> {
   charCodeAt(index: i32): i32;
   codePointAt(index: i32): i32;
   concat(other: string): string;
-  endsWith(other: string): bool;
+  endsWith(other: string, position?: i32): bool;
   indexOf(other: string, fromIndex?: i32): i32;
   lastIndexOf(other: string, fromIndex?: i32): i32;
   localeCompare(other: string): i32;
   includes(other: string): bool;
-  startsWith(other: string): bool;
+  startsWith(other: string, position?: i32): bool;
   substr(start: i32, length?: i32): string;
   substring(start: i32, end?: i32): string;
   trim(): string;
@@ -2395,6 +2140,8 @@ declare class URIError extends Error {}
 interface Function {
   /** Function table index. */
   readonly index: u32;
+  /** Function closure environment pointer. */
+  readonly env: usize;
   /** Function name. Always an empty string. */
   readonly name: string;
   /** Number of expected parameters. */

package/types/warpo/index.d.ts

@@ -23,3 +23,97 @@ declare module "warpo/utf8/const_str" {
   }
   function build(s: string): ConstStr;
 }
+
+declare module "warpo/test" {
+  export class MockFn {
+    constructor(originalFunctionIndex: u32, mockFunctionIndex: u32);
+    get calls(): u32;
+  }
+
+  export class Value<T> {
+    get not(): this;
+
+    isNull(): this;
+    notNull(): this;
+
+    equal(checkValue: T): this;
+    notEqual(checkValue: T): this;
+
+    greaterThan(checkValue: T): this;
+    greaterThanOrEqual(checkValue: T): this;
+    lessThan(checkValue: T): this;
+    lessThanOrEqual(checkValue: T): this;
+
+    closeTo(checkValue: T, delta: number): this;
+
+    isa<ExpectType>(): this;
+
+    isExactly<ExpectType>(): this;
+  }
+
+  /**
+   *  describe a test group
+   * @param description common description of each test inside
+   * @param testsFunction can call multi-time test
+   */
+  export function describe(description: string, testsFunction: () => void): void;
+
+  /**
+   *  run a test
+   * @param name test name
+   * @param testFunction main function of test
+   */
+  export function test(name: string, testFunction: () => void): void;
+
+  /**
+   * setup function before each test
+   * must be called inside describe block
+   * @example
+   * ```ts
+   * describe("test group", () => {
+   *  beforeEach(() => {
+   *    // setup code
+   *  });
+   *  test("test case", () => {
+   *    // test code
+   *  });
+   * });
+   */
+  export function beforeEach(func: () => void): void;
+
+  /**
+   * teardown function after each test
+   * must be called inside describe block
+   * @example
+   * ```ts
+   * describe("test group", () => {
+   *  afterEach(() => {
+   *    // teardown code
+   *  });
+   *  test("test case", () => {
+   *    // test code
+   *  });
+   * });
+   */
+  export function afterEach(func: () => void): void;
+
+  /**
+   *  mock some function
+   * @param originalFunction function you want to mock
+   * @param mockFunction the new function.
+   * @returns MockFn with call information (e.g. via its `calls` property)
+   */
+  export function mock<T extends Function>(originalFunction: T, mockFunction: T): MockFn;
+
+  /**
+   * unmock this function, can only be used in mocked function
+   */
+  export function unmock<T extends Function>(originalFunction: T): void;
+
+  /**
+   * remock this function, can only be used in mocked function. Pair of {unmock}
+   */
+  export function remock<T extends Function>(originalFunction: T): void;
+
+  export function expect<T>(value: T): Value<T>;
+}

package/dist/lib.d.ts

@@ -1,5 +0,0 @@
-export interface Option {
-    env: NodeJS.Dict<string>;
-    argv: string[];
-}
-export declare function main(options: Option): Promise<number>;