docs: update pkg meta (keywords) #1589
postspectacularAnnotations
8 errors
|
error: expect(received).toMatchSnapshot(expected):
packages/wasm-api-bindgen/test/main.test.ts#L40
Expected:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringSlice, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface Foo extends WasmTypeBase {
single: WasmStringSlice;
constSingle: WasmStringSlice;
multi: WasmStringSlice[];
singlePtr: Pointer<WasmStringSlice>;
multiPtr: Pointer<WasmStringSlice[]>;
slice: WasmStringSlice[];
constSlice: WasmStringSlice[];
}
export const $Foo: WasmTypeConstructor<Foo> = (mem) => ({
get align() {
return 4;
},
get size() {
return 56;
},
instanceArray(base, num) {
return __instanceArray<Foo>(this, base, num);
},
instance: (base) => {
let $singlePtr: Pointer<WasmStringSlice> | null = null;
let $multiPtr: Pointer<WasmStringSlice[]> | null = null;
let $single: WasmStringSlice | null = null;
let $constSingle: WasmStringSlice | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 56);
},
get single(): WasmStringSlice {
return $single || ($single = new WasmStringSlice(mem, base, false));
},
get constSingle(): WasmStringSlice {
return $constSingle || ($constSingle = new WasmStringSlice(mem, (base + 8), true));
},
get multi(): WasmStringSlice[] {
const addr = (base + 16);
const $multi: WasmStringSlice[] = [];
for(let i = 0; i < 2; i++) $multi.push(new WasmStringSlice(mem, addr + i * 8, true));
return $multi;
},
get singlePtr(): Pointer<WasmStringSlice> {
return $singlePtr || ($singlePtr = new Pointer<WasmStringSlice>(mem, (base + 32),
(addr) => new WasmStringSlice(mem, addr, true)
));
},
get multiPtr(): Pointer<WasmStringSlice[]> {
return $multiPtr || ($multiPtr = new Pointer<WasmStringSlice[]>(mem, (base + 36),
(addr) => {
const $buf: WasmStringSlice[] = [];
for(let i = 0; i < 2; i++) $buf.push(new WasmStringSlice(mem, addr + i * 8, true));
return $buf;
}
));
},
get slice(): WasmStringSlice[] {
const addr = mem.u32[(base + 40) >>> 2];
const len = mem.u32[(base + 44) >>> 2];
const $slice: WasmStringSlice[] = [];
for(let i = 0; i < len; i++) $slice.push(new WasmStringSlice(mem, addr + i * 8, false));
return $slice;
},
get constSlice(): WasmStringSlice[] {
const addr = mem.u32[(base + 48) >>> 2];
const len = mem.u32[(base + 52) >>> 2];
const $constSlice: WasmStringSlice[] = [];
for(let i = 0; i < len; i++) $constSlice.push(new WasmStringSlice(mem, addr + i * 8, true));
return $constSlice;
},
};
}
});
"
Received:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringSlice, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface Foo extends WasmTypeBase {
readonly single: WasmStringSlice;
readonly constSingle: WasmStringSlice;
readonly multi: WasmStringSlice[];
readonly singlePtr: Pointer<WasmStringSlice>;
readonly multiPtr: Pointer<WasmStringSlice[]>;
readonly slice: WasmStringSlice[];
readonly constSlice: WasmStringSlice[];
}
export const $Foo: WasmTypeConstructor<Foo> = (mem) => ({
get align() {
return 4;
},
get size() {
return 56;
},
instanceArray(base, num) {
return __instanceArray<Foo>(this, base, num);
},
instance: (base) => {
let $singlePtr: Pointer<WasmStringSlice> | null = null;
let $multiPtr: Pointer<WasmStringSlice[]> | null = null;
let $single: WasmStringSlice | null = null;
let $constSingle: WasmStringSlice | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 56);
},
get single(): WasmStringSlice {
return $single || ($single = new WasmStringSlice(mem, base, false));
},
get constSingle(): WasmStringSlice {
return $constSingle || ($constSingle = new WasmStringSlice(mem, (base + 8), true));
},
get multi(): WasmStringSlice[] {
const addr = (base + 16);
const $multi: WasmStringSlice[] = [];
for(let i = 0; i < 2;
|
|
error: expect(received).toMatchSnapshot(expected):
packages/wasm-api-bindgen/test/main.test.ts#L40
Expected:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface Foo extends WasmTypeBase {
single: WasmStringPtr;
constSingle: WasmStringPtr;
multi: WasmStringPtr[];
singlePtr: Pointer<WasmStringPtr>;
multiPtr: Pointer<WasmStringPtr[]>;
slice: WasmStringPtr[];
constSlice: WasmStringPtr[];
}
export const $Foo: WasmTypeConstructor<Foo> = (mem) => ({
get align() {
return 4;
},
get size() {
return 56;
},
instanceArray(base, num) {
return __instanceArray<Foo>(this, base, num);
},
instance: (base) => {
let $singlePtr: Pointer<WasmStringPtr> | null = null;
let $multiPtr: Pointer<WasmStringPtr[]> | null = null;
let $single: WasmStringPtr | null = null;
let $constSingle: WasmStringPtr | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 56);
},
get single(): WasmStringPtr {
return $single || ($single = new WasmStringPtr(mem, base, false));
},
get constSingle(): WasmStringPtr {
return $constSingle || ($constSingle = new WasmStringPtr(mem, (base + 8), true));
},
get multi(): WasmStringPtr[] {
const addr = (base + 16);
const $multi: WasmStringPtr[] = [];
for(let i = 0; i < 2; i++) $multi.push(new WasmStringPtr(mem, addr + i * 4, true));
return $multi;
},
get singlePtr(): Pointer<WasmStringPtr> {
return $singlePtr || ($singlePtr = new Pointer<WasmStringPtr>(mem, (base + 32),
(addr) => new WasmStringPtr(mem, addr, true)
));
},
get multiPtr(): Pointer<WasmStringPtr[]> {
return $multiPtr || ($multiPtr = new Pointer<WasmStringPtr[]>(mem, (base + 36),
(addr) => {
const $buf: WasmStringPtr[] = [];
for(let i = 0; i < 2; i++) $buf.push(new WasmStringPtr(mem, addr + i * 4, true));
return $buf;
}
));
},
get slice(): WasmStringPtr[] {
const addr = mem.u32[(base + 40) >>> 2];
const len = mem.u32[(base + 44) >>> 2];
const $slice: WasmStringPtr[] = [];
for(let i = 0; i < len; i++) $slice.push(new WasmStringPtr(mem, addr + i * 4, false));
return $slice;
},
get constSlice(): WasmStringPtr[] {
const addr = mem.u32[(base + 48) >>> 2];
const len = mem.u32[(base + 52) >>> 2];
const $constSlice: WasmStringPtr[] = [];
for(let i = 0; i < len; i++) $constSlice.push(new WasmStringPtr(mem, addr + i * 4, true));
return $constSlice;
},
};
}
});
"
Received:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface Foo extends WasmTypeBase {
readonly single: WasmStringPtr;
readonly constSingle: WasmStringPtr;
readonly multi: WasmStringPtr[];
readonly singlePtr: Pointer<WasmStringPtr>;
readonly multiPtr: Pointer<WasmStringPtr[]>;
readonly slice: WasmStringPtr[];
readonly constSlice: WasmStringPtr[];
}
export const $Foo: WasmTypeConstructor<Foo> = (mem) => ({
get align() {
return 4;
},
get size() {
return 56;
},
instanceArray(base, num) {
return __instanceArray<Foo>(this, base, num);
},
instance: (base) => {
let $singlePtr: Pointer<WasmStringPtr> | null = null;
let $multiPtr: Pointer<WasmStringPtr[]> | null = null;
let $single: WasmStringPtr | null = null;
let $constSingle: WasmStringPtr | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 56);
},
get single(): WasmStringPtr {
return $single || ($single = new WasmStringPtr(mem, base, false));
},
get constSingle(): WasmStringPtr {
return $constSingle || ($constSingle = new WasmStringPtr(mem, (base + 8), true));
},
get multi(): WasmStringPtr[] {
const addr = (base + 16);
const $multi: WasmStringPtr[] = [];
for(let i = 0; i < 2; i++) $multi.push(new WasmStringPtr(mem, addr + i * 4, true));
return $multi;
},
get singlePtr(): Po
|
|
error: expect(received).toMatchSnapshot(expected):
packages/wasm-api-bindgen/test/main.test.ts#L40
Expected:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface A extends WasmTypeBase {
/**
* Zig type: \`u8\`
*/
a: number;
/**
* Zig type: \`u32\`
*/
b: number;
/**
* Zig type: \`*[3]u16\`
*/
c: Pointer<Uint16Array>;
/**
* Zig type: \`f64\`
*/
d: number;
}
export const $A: WasmTypeConstructor<A> = (mem) => ({
get align() {
return 8;
},
get size() {
return 24;
},
instanceArray(base, num) {
return __instanceArray<A>(this, base, num);
},
instance: (base) => {
let $c: Pointer<Uint16Array> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 24);
},
get a(): number {
return mem.u8[base];
},
set a(x: number) {
mem.u8[base] = x;
},
get b(): number {
return mem.u32[(base + 4) >>> 2];
},
set b(x: number) {
mem.u32[(base + 4) >>> 2] = x;
},
get c(): Pointer<Uint16Array> {
return $c || ($c = new Pointer<Uint16Array>(mem, (base + 8),
(addr) => mem.u16.subarray(addr, addr + 3)
));
},
get d(): number {
return mem.f64[(base + 16) >>> 3];
},
set d(x: number) {
mem.f64[(base + 16) >>> 3] = x;
},
};
}
});
export interface B extends WasmTypeBase {
a: A[];
/**
* Zig type: \`u64\`
*/
b: bigint;
}
export const $B: WasmTypeConstructor<B> = (mem) => ({
get align() {
return 8;
},
get size() {
return 72;
},
instanceArray(base, num) {
return __instanceArray<B>(this, base, num);
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 72);
},
get a(): A[] {
return __array(mem, $A, base, 3);
},
get b(): bigint {
return mem.u64[base >>> 3];
},
set b(x: bigint) {
mem.u64[base >>> 3] = x;
},
};
}
});
"
Received:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface A extends WasmTypeBase {
/**
* Zig type: \`u8\`
*/
a: number;
/**
* Zig type: \`u32\`
*/
b: number;
/**
* Zig type: \`*[3]u16\`
*/
readonly c: Pointer<Uint16Array>;
/**
* Zig type: \`f64\`
*/
d: number;
}
export const $A: WasmTypeConstructor<A> = (mem) => ({
get align() {
return 8;
},
get size() {
return 24;
},
instanceArray(base, num) {
return __instanceArray<A>(this, base, num);
},
instance: (base) => {
let $c: Pointer<Uint16Array> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 24);
},
get a(): number {
return mem.u8[base];
},
set a(x: number) {
mem.u8[base] = x;
},
get b(): number {
return mem.u32[(base + 4) >>> 2];
},
set b(x: number) {
mem.u32[(base + 4) >>> 2] = x;
},
get c(): Pointer<Uint16Array> {
return $c || ($c = new Pointer<Uint16Array>(mem, (base + 8),
(addr) => mem.u16.subarray(addr, addr + 3)
));
},
get d(): number {
return mem.f64[(base + 16) >>> 3];
},
set d(x: number) {
mem.f64[(base + 16) >>> 3] = x;
},
};
}
});
export interface B extends WasmTypeBase {
readonly a: A[];
/**
* Zig type: \`u64\`
*/
b: bigint;
}
export const $B: WasmTypeConstructor<B> = (mem) => ({
get align() {
return 8;
},
get size() {
return 72;
},
instanceArray(base, num) {
return __instanceArray<B>(this, base, num);
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 72);
},
get a(): A[] {
return __array(mem, $A, base, 3);
},
get b(): bigint {
return mem.u64[base >>> 3];
},
set b(x: bigint) {
mem.u64[base >>> 3] = x;
},
};
}
});
"
at checkFixture (/home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:40:41)
at checkAll (/home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:46:2)
at /
|
|
error: expect(received).toMatchSnapshot(expected):
packages/wasm-api-bindgen/test/main.test.ts#L40
Expected:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface A extends WasmTypeBase {
/**
* Zig type: \`u32\`
*/
a: number;
/**
* Zig type: \`*u32\`
*/
ptr: Pointer<number>;
/**
* Zig type: \`*[2]u32\`
*/
ptr2: Pointer<Uint32Array>;
/**
* Zig type: \`*const u32\`
*/
constPtr: Pointer<number>;
/**
* Zig type: \`U32Slice\`
*/
slice: Uint32Array;
/**
* Zig type: \`ConstU32Slice\`
*/
constSlice: Uint32Array;
/**
* Zig type: \`[3]u32\`
*/
array: Uint32Array;
/**
* Zig type: \`[3]u32\`
*/
constArray: Uint32Array;
}
export const $A: WasmTypeConstructor<A> = (mem) => ({
get align() {
return 4;
},
get size() {
return 56;
},
instanceArray(base, num) {
return __instanceArray<A>(this, base, num);
},
instance: (base) => {
let $ptr: Pointer<number> | null = null;
let $ptr2: Pointer<Uint32Array> | null = null;
let $constPtr: Pointer<number> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 56);
},
get a(): number {
return mem.u32[base >>> 2];
},
set a(x: number) {
mem.u32[base >>> 2] = x;
},
get ptr(): Pointer<number> {
return $ptr || ($ptr = new Pointer<number>(mem, (base + 4),
(addr) => mem.u32[addr >>> 2]
));
},
get ptr2(): Pointer<Uint32Array> {
return $ptr2 || ($ptr2 = new Pointer<Uint32Array>(mem, (base + 8),
(addr) => mem.u32.subarray(addr, addr + 2)
));
},
get constPtr(): Pointer<number> {
return $constPtr || ($constPtr = new Pointer<number>(mem, (base + 12),
(addr) => mem.u32[addr >>> 2]
));
},
get slice(): Uint32Array {
return __primslice32(mem, mem.u32, (base + 16), 2);
},
get constSlice(): Uint32Array {
return __primslice32(mem, mem.u32, (base + 24), 2);
},
get array(): Uint32Array {
const addr = (base + 32) >>> 2;
return mem.u32.subarray(addr, addr + 3);
},
get constArray(): Uint32Array {
const addr = (base + 44) >>> 2;
return mem.u32.subarray(addr, addr + 3);
},
};
}
});
"
Received:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface A extends WasmTypeBase {
/**
* Zig type: \`u32\`
*/
a: number;
/**
* Zig type: \`*u32\`
*/
readonly ptr: Pointer<number>;
/**
* Zig type: \`*[2]u32\`
*/
readonly ptr2: Pointer<Uint32Array>;
/**
* Zig type: \`*const u32\`
*/
readonly constPtr: Pointer<number>;
/**
* Zig type: \`U32Slice\`
*/
readonly slice: Uint32Array;
/**
* Zig type: \`ConstU32Slice\`
*/
readonly constSlice: Uint32Array;
/**
* Zig type: \`[3]u32\`
*/
readonly array: Uint32Array;
/**
* Zig type: \`[3]u32\`
*/
readonly constArray: Uint32Array;
}
export const $A: WasmTypeConstructor<A> = (mem) => ({
get align() {
return 4;
},
get size() {
return 56;
},
instanceArray(base, num) {
return __instanceArray<A>(this, base, num);
},
instance: (base) => {
let $ptr: Pointer<number> | null = null;
let $ptr2: Pointer<Uint32Array> | null = null;
let $constPtr: Pointer<number> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 56);
},
get a(): number {
return mem.u32[base >>> 2];
},
set a(x: number) {
mem.u32[base >>> 2] = x;
},
get ptr(): Pointer<number> {
return $ptr || ($ptr = new Pointer<number>(mem, (base + 4),
(addr) => mem.u32[addr >>> 2]
));
},
get ptr2(): Pointer<Uint32Array> {
return $ptr2 || ($ptr2 = new Pointer<Uint32Array>(mem, (base + 8),
(addr) => mem.u32.subarray(addr, addr + 2)
));
},
get constPtr(): Pointer<number> {
return $constPtr || ($constPtr = new Pointer<number>(mem, (base + 12),
(addr) => mem.u32[addr >>> 2]
));
},
get slice(): Uint32Array {
return __primslice32(mem, mem.u32, (ba
|
|
error: expect(received).toMatchSnapshot(expected):
packages/wasm-api-bindgen/test/main.test.ts#L40
Expected:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export enum A {
FOO,
BAR,
BAZ = 10,
}
export interface B extends WasmTypeBase {
single: A;
array: Int32Array;
slice: Int32Array;
ptr: Pointer<A>;
ptr2: Pointer<Int32Array>;
}
export const $B: WasmTypeConstructor<B> = (mem) => ({
get align() {
return 4;
},
get size() {
return 28;
},
instanceArray(base, num) {
return __instanceArray<B>(this, base, num);
},
instance: (base) => {
let $ptr: Pointer<A> | null = null;
let $ptr2: Pointer<Int32Array> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 28);
},
get single(): A {
return mem.i32[base >>> 2];
},
set single(x: A) {
mem.i32[base >>> 2] = x;
},
get array(): Int32Array {
const addr = (base + 4) >>> 2;
return mem.i32.subarray(addr, addr + 2);
},
get slice(): Int32Array {
return __primslice32(mem, mem.i32, (base + 12), 2);
},
get ptr(): Pointer<A> {
return $ptr || ($ptr = new Pointer<A>(mem, (base + 20),
(addr) => mem.i32[addr >>> 2]
));
},
get ptr2(): Pointer<Int32Array> {
return $ptr2 || ($ptr2 = new Pointer<Int32Array>(mem, (base + 24),
(addr) => mem.i32.subarray(addr, addr + 2)
));
},
};
}
});
"
Received:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export enum A {
FOO,
BAR,
BAZ = 10,
}
export interface B extends WasmTypeBase {
single: A;
readonly array: Int32Array;
readonly slice: Int32Array;
readonly ptr: Pointer<A>;
readonly ptr2: Pointer<Int32Array>;
}
export const $B: WasmTypeConstructor<B> = (mem) => ({
get align() {
return 4;
},
get size() {
return 28;
},
instanceArray(base, num) {
return __instanceArray<B>(this, base, num);
},
instance: (base) => {
let $ptr: Pointer<A> | null = null;
let $ptr2: Pointer<Int32Array> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 28);
},
get single(): A {
return mem.i32[base >>> 2];
},
set single(x: A) {
mem.i32[base >>> 2] = x;
},
get array(): Int32Array {
const addr = (base + 4) >>> 2;
return mem.i32.subarray(addr, addr + 2);
},
get slice(): Int32Array {
return __primslice32(mem, mem.i32, (base + 12), 2);
},
get ptr(): Pointer<A> {
return $ptr || ($ptr = new Pointer<A>(mem, (base + 20),
(addr) => mem.i32[addr >>> 2]
));
},
get ptr2(): Pointer<Int32Array> {
return $ptr2 || ($ptr2 = new Pointer<Int32Array>(mem, (base + 24),
(addr) => mem.i32.subarray(addr, addr + 2)
));
},
};
}
});
"
at checkFixture (/home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:40:41)
at checkAll (/home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:46:2)
at /home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:309:2
|
|
error: expect(received).toMatchSnapshot(expected):
packages/wasm-api-bindgen/test/main.test.ts#L40
Expected:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface B extends WasmTypeBase {
/**
* Zig type: \`u32\`
*/
a: number;
/**
* Zig type: \`*u32\`
*/
ptr: Pointer<number>;
/**
* Zig type: \`*[2]u32\`
*/
ptr2: Pointer<Uint32Array>;
/**
* Zig type: \`[2]u32\`
*/
array: Uint32Array;
/**
* Zig type: \`U32Slice\`
*/
slice: Uint32Array;
}
export const $B: WasmTypeConstructor<B> = (mem) => ({
get align() {
return 4;
},
get size() {
return 28;
},
instanceArray(base, num) {
return __instanceArray<B>(this, base, num);
},
instance: (base) => {
let $ptr: Pointer<number> | null = null;
let $ptr2: Pointer<Uint32Array> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 28);
},
get a(): number {
return mem.u32[base >>> 2];
},
set a(x: number) {
mem.u32[base >>> 2] = x;
},
get ptr(): Pointer<number> {
return $ptr || ($ptr = new Pointer<number>(mem, (base + 4),
(addr) => mem.u32[addr >>> 2]
));
},
get ptr2(): Pointer<Uint32Array> {
return $ptr2 || ($ptr2 = new Pointer<Uint32Array>(mem, (base + 8),
(addr) => mem.u32.subarray(addr, addr + 2)
));
},
get array(): Uint32Array {
const addr = (base + 12) >>> 2;
return mem.u32.subarray(addr, addr + 2);
},
get slice(): Uint32Array {
return __primslice32(mem, mem.u32, (base + 20), 2);
},
};
}
});
"
Received:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface B extends WasmTypeBase {
/**
* Zig type: \`u32\`
*/
a: number;
/**
* Zig type: \`*u32\`
*/
readonly ptr: Pointer<number>;
/**
* Zig type: \`*[2]u32\`
*/
readonly ptr2: Pointer<Uint32Array>;
/**
* Zig type: \`[2]u32\`
*/
readonly array: Uint32Array;
/**
* Zig type: \`U32Slice\`
*/
readonly slice: Uint32Array;
}
export const $B: WasmTypeConstructor<B> = (mem) => ({
get align() {
return 4;
},
get size() {
return 28;
},
instanceArray(base, num) {
return __instanceArray<B>(this, base, num);
},
instance: (base) => {
let $ptr: Pointer<number> | null = null;
let $ptr2: Pointer<Uint32Array> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 28);
},
get a(): number {
return mem.u32[base >>> 2];
},
set a(x: number) {
mem.u32[base >>> 2] = x;
},
get ptr(): Pointer<number> {
return $ptr || ($ptr = new Pointer<number>(mem, (base + 4),
(addr) => mem.u32[addr >>> 2]
));
},
get ptr2(): Pointer<Uint32Array> {
return $ptr2 || ($ptr2 = new Pointer<Uint32Array>(mem, (base + 8),
(addr) => mem.u32.subarray(addr, addr + 2)
));
},
get array(): Uint32Array {
const addr = (base + 12) >>> 2;
return mem.u32.subarray(addr, addr + 2);
},
get slice(): Uint32Array {
return __primslice32(mem, mem.u32, (base + 20), 2);
},
};
}
});
"
at checkFixture (/home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:40:41)
at checkAll (/home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:46:2)
at /home/runner/work/umbrella/umbrella/packages/wasm-api-bindgen/test/main.test.ts:402:2
|
|
error: expect(received).toMatchSnapshot(expected):
packages/wasm-api-bindgen/test/main.test.ts#L40
Expected:
"// @ts-ignore possibly includes unused imports
import { Pointer, WasmStringPtr, type IWasmMemoryAccess, type MemorySlice, type MemoryView, type WasmType, type WasmTypeBase, type WasmTypeConstructor } from "@thi.ng/wasm-api";
// @ts-ignore
import { __array, __instanceArray, __slice32, __primslice32 } from "@thi.ng/wasm-api/memory";
export interface A extends WasmTypeBase {
/**
* Zig type: \`u16\`
*/
a: number;
}
export const $A: WasmTypeConstructor<A> = (mem) => ({
get align() {
return 2;
},
get size() {
return 2;
},
instanceArray(base, num) {
return __instanceArray<A>(this, base, num);
},
instance: (base) => {
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 2);
},
get a(): number {
return mem.u16[base >>> 1];
},
set a(x: number) {
mem.u16[base >>> 1] = x;
},
};
}
});
export interface B extends WasmTypeBase {
/**
* Zig type: \`U8Slice\`
*/
slice: Uint8Array;
/**
* Zig type: \`ConstU8Slice\`
*/
constSlice: Uint8Array;
/**
* Zig type: \`*u8\`
*/
ptr: Pointer<number>;
/**
* Zig type: \`*const u8\`
*/
constPtr: Pointer<number>;
/**
* Zig type: \`*[2]u8\`
*/
ptr2: Pointer<Uint8Array>;
/**
* Zig type: \`*[2:0]u8\`
*/
ptr2sentinel: Pointer<Uint8Array>;
/**
* Zig type: \`*const [2]u8\`
*/
constPtr2: Pointer<Uint8Array>;
/**
* Zig type: \`*const [2:0]u8\`
*/
constPtr2sentinel: Pointer<Uint8Array>;
/**
* Multi pointer: \`[*]u8\`
*
* @remarks
* Only the pointer's target address can be accessed
*/
ptrMulti: number;
/**
* Multi pointer: \`[*:255]u8\`
*
* @remarks
* Only the pointer's target address can be accessed
*/
ptrMultiSentinel: number;
/**
* Multi pointer: \`[*]const u8\`
*
* @remarks
* Only the pointer's target address can be accessed
*/
constPtrMulti: number;
/**
* Multi pointer: \`[*:255]const u8\`
*
* @remarks
* Only the pointer's target address can be accessed
*/
constPtrMultiSentinel: number;
/**
* Zig type: \`[2]i32\`
*/
array: Int32Array;
/**
* Zig type: \`[2:0]i32\`
*/
arraySentinel: Int32Array;
aSingle: A;
aSlice: A[];
constASlice: A[];
aPtr: Pointer<A>;
aPtr2: Pointer<A[]>;
/**
* Multiple A's
*
* @remarks
* Multi pointer: \`[*]A\`
* Only the pointer's target address can be accessed
*/
aPtrMulti: number;
}
export const $B: WasmTypeConstructor<B> = (mem) => ({
get align() {
return 4;
},
get size() {
return 108;
},
instanceArray(base, num) {
return __instanceArray<B>(this, base, num);
},
instance: (base) => {
let $ptr: Pointer<number> | null = null;
let $constPtr: Pointer<number> | null = null;
let $ptr2: Pointer<Uint8Array> | null = null;
let $ptr2sentinel: Pointer<Uint8Array> | null = null;
let $constPtr2: Pointer<Uint8Array> | null = null;
let $constPtr2sentinel: Pointer<Uint8Array> | null = null;
let $aPtr: Pointer<A> | null = null;
let $aPtr2: Pointer<A[]> | null = null;
return {
get __base() {
return base;
},
get __bytes() {
return mem.u8.subarray(base, base + 108);
},
get slice(): Uint8Array {
return __primslice32(mem, mem.u8, base, 0);
},
get constSlice(): Uint8Array {
return __primslice32(mem, mem.u8, (base + 8), 0);
},
get ptr(): Pointer<number> {
return $ptr || ($ptr = new Pointer<number>(mem, (base + 16),
(addr) => mem.u8[addr >>> 0]
));
},
get constPtr(): Pointer<number> {
return $constPtr || ($constPtr = new Pointer<number>(mem, (base + 20),
(addr) => mem.u8[addr >>> 0]
));
},
get ptr2(): Pointer<Uint8Array> {
return $ptr2 || ($ptr2 = new Pointer<Uint8Array>(mem, (base + 24),
(addr) => mem.u8.subarray(addr, addr + 2)
));
},
get ptr2sentinel(): Pointer<Uint8Array> {
return $ptr2sentinel || ($ptr2sentinel = new Pointer<Uint8Array>(mem, (base + 28),
(addr) => mem.u8.subarray(addr, addr + 2)
));
},
get constPtr2(): Pointer<Uint8Array> {
return $constPtr2 || ($constPtr2 = new Pointer<Uint8Array>(mem, (base + 32),
(addr) => mem.u8.subarray(addr, addr + 2)
));
},
get constPtr2sentinel(): Pointer<Uint8Array> {
return $constPtr2sentinel || ($constPtr2sentinel = new Pointer<Uint8Array>(mem, (base + 36),
(addr) => mem.u8.subarray(addr, addr + 2)
));
},
get ptrMulti(): number {
return mem.u32[(base + 40) >>
|
|
test
Process completed with exit code 1.
|