BigfootDev/flatbuffers
1
0
Fork 1
mirror of https://github.com/google/flatbuffers.git synced 2026-06-24 21:26:09 +00:00
Code Issues Packages Projects Releases Wiki Activity

[TS/JS] New gen TS code gen (#6302)

Browse Source 
* TS/ES6 modules spike iteration 1

* Initial modularized dasherized output

* Remove obsoleted parts and namespace wrapping

* Use _flatbuffers_ prefix

* First part of imports logic

* Second part of imports logic

* Fix TS/JS code removal mixup

* Alias imported symbols if same name from different namespaces and some fixes

* Use star import for bare imports

* Fix messed up string concat

* var to const and remove not needed semi

* Remove some cases of ns prefixing

* Add missing space

* Cleanups

* Completed initial import tracking logic

* Compilable output

* Adjust TypeScriptTest and dependents to work

* Use local flatbuffers package for tests

* Refactor away use of any

* Remove obsolete imported_fileset and reexport_map

* Still need any and fix JavaScriptTest.sh

* Fix test runs out of the box

* Temp add generated files

* TypeScriptTest replaces JavaScriptTest and cleanups

* Also remove reference to JavaScriptTest in TestAll.sh

* Remove old generated ts/js files

* Remove use of --js in generate_code scripts

* idl_gen_js_ts to idl_gen_ts and removal of js gen

* Remove obsoleted options

* Fix obsolete ts test detection

* Tweak ts compilation be as strict as possible

* Remove jsdoc type annotation generation

* Generated test ts files

* Fix search and replace messup

* Regenerated ts test output

* Use CharToLower

* Use normal for loop

* Rework namespacedir

* Revert "Rework namespacedir"

This reverts commit 6f4eb0104ceeb86011bb076ebca901138c48e068.

* Revert "Use normal for loop"

This reverts commit 676b2135bfaa1853dfbb06c92b5c16a0d81bb13a.

* Revert "Use CharToLower"

This reverts commit 2d08648d0d72d0af201fad80d54cdc76412b35e9.

* Again do rework but correct

* Avoid runtime cast

* Fix test runs

* Also add npm install to get tsc

* Bump node test versions

* for range to std for loop

* Clang format

* Missed one clang format

* Move accessor to later

* Attempt to make windows version of TypeScriptTest

* Want to see the output

* Try to get newer node at appveyor

* Style changes
This commit is contained in:
Björn Harrtell
2021-01-19 21:51:13 +01:00
committed by GitHub
parent 75c859e98f
commit 760c657551
56 changed files with 3870 additions and 4035 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
tests/JavaScriptFlexBuffersTest.js
View File

@@ -1,9 +1,7 @@
// Run this using JavaScriptTest.sh
var assert = require('assert');
var fs = require('fs');
var flexbuffers = require('../js/flexbuffers').flexbuffers;
global.flexbuffers = flexbuffers;
import assert from 'assert'
import fs from 'fs'
import * as flexbuffers from 'flatbuffers/js/flexbuffers'
function main() {
testSingleValueBuffers();
@@ -16,10 +14,12 @@ function main() {
testRoundTripWithBuilder();
testDeduplicationOff();
testBugWhereOffestWereStoredAsIntInsteadOfUInt();
console.log('FlexBuffers test: completed successfully');
}
function testSingleValueBuffers() {
{ // null
{
const ref = flexbuffers.toReference(new Uint8Array([0, 0, 1]).buffer);
assert.strictEqual(true, ref.isNull());
}

159
tests/JavaScriptTest.js
View File

@@ -1,13 +1,14 @@
// Run this using JavaScriptTest.sh
var assert = require('assert');
var fs = require('fs');
import assert from 'assert'
import fs from 'fs'
import * as flatbuffers from 'flatbuffers'
var flatbuffers = require('../js/flatbuffers').flatbuffers;
global.flatbuffers = flatbuffers;
var MyGame = require(process.argv[2]).MyGame;
var isTsTest = !!process.env.FB_TS_TEST;
import { Monster, MonsterT } from './ts/my-game/example/monster'
import { Test } from './ts/my-game/example/test'
import { Stat } from './ts/my-game/example/stat'
import { Vec3 } from './ts/my-game/example/vec3'
import { Color } from './ts/my-game/example/color';
import { Any } from './ts/my-game/example/any';
function main() {
@@ -27,11 +28,8 @@ function main() {
var fbb = new flatbuffers.Builder(1);
createMonster(fbb);
serializeAndTest(fbb);
testObjApiPack(fbb);
if(isTsTest) {
testObjApiPack(fbb);
}
// clear the builder, repeat tests
var clearIterations = 100;
var startingCapacity = fbb.bb.capacity();
@@ -39,10 +37,7 @@ function main() {
fbb.clear();
createMonster(fbb);
serializeAndTest(fbb);
if(isTsTest) {
testObjApiPack(fbb);
}
testObjApiPack(fbb);
}
// the capacity of our buffer shouldn't increase with the same size payload
assert.strictEqual(fbb.bb.capacity(), startingCapacity);
@@ -52,7 +47,7 @@ function main() {
fuzzTest1();
testNullStrings();
testSharedStrings();
console.log('FlatBuffers test: completed successfully');
}
@@ -61,36 +56,36 @@ function createMonster(fbb) {
var str = fbb.createString('MyMonster');
var inv = MyGame.Example.Monster.createInventoryVector(fbb, [0, 1, 2, 3, 4]);
var inv = Monster.createInventoryVector(fbb, [0, 1, 2, 3, 4]);
var fred = fbb.createString('Fred');
MyGame.Example.Monster.startMonster(fbb);
MyGame.Example.Monster.addName(fbb, fred);
var mon2 = MyGame.Example.Monster.endMonster(fbb);
Monster.startMonster(fbb);
Monster.addName(fbb, fred);
var mon2 = Monster.endMonster(fbb);
MyGame.Example.Monster.startTest4Vector(fbb, 2);
MyGame.Example.Test.createTest(fbb, 10, 20);
MyGame.Example.Test.createTest(fbb, 30, 40);
Monster.startTest4Vector(fbb, 2);
Test.createTest(fbb, 10, 20);
Test.createTest(fbb, 30, 40);
var test4 = fbb.endVector();
var testArrayOfString = MyGame.Example.Monster.createTestarrayofstringVector(fbb, [
var testArrayOfString = Monster.createTestarrayofstringVector(fbb, [
fbb.createString('test1'),
fbb.createString('test2')
]);
MyGame.Example.Monster.startMonster(fbb);
MyGame.Example.Monster.addPos(fbb, MyGame.Example.Vec3.createVec3(fbb, 1, 2, 3, 3, MyGame.Example.Color.Green, 5, 6));
MyGame.Example.Monster.addHp(fbb, 80);
MyGame.Example.Monster.addName(fbb, str);
MyGame.Example.Monster.addInventory(fbb, inv);
MyGame.Example.Monster.addTestType(fbb, MyGame.Example.Any.Monster);
MyGame.Example.Monster.addTest(fbb, mon2);
MyGame.Example.Monster.addTest4(fbb, test4);
MyGame.Example.Monster.addTestarrayofstring(fbb, testArrayOfString);
MyGame.Example.Monster.addTestbool(fbb, true);
var mon = MyGame.Example.Monster.endMonster(fbb);
Monster.startMonster(fbb);
Monster.addPos(fbb, Vec3.createVec3(fbb, 1, 2, 3, 3, Color.Green, 5, 6));
Monster.addHp(fbb, 80);
Monster.addName(fbb, str);
Monster.addInventory(fbb, inv);
Monster.addTestType(fbb, Any.Monster);
Monster.addTest(fbb, mon2);
Monster.addTest4(fbb, test4);
Monster.addTestarrayofstring(fbb, testArrayOfString);
Monster.addTestbool(fbb, true);
var mon = Monster.endMonster(fbb);
MyGame.Example.Monster.finishMonsterBuffer(fbb, mon);
Monster.finishMonsterBuffer(fbb, mon);
}
function serializeAndTest(fbb) {
@@ -109,7 +104,7 @@ function serializeAndTest(fbb) {
}
function testMutation(bb) {
var monster = MyGame.Example.Monster.getRootAsMonster(bb);
var monster = Monster.getRootAsMonster(bb);
monster.mutate_hp(120);
assert.strictEqual(monster.hp(), 120);
@@ -126,9 +121,9 @@ function testMutation(bb) {
function testObjApiPack(fbb) {
fbb.clear();
createMonster(fbb);
let monster_t = MyGame.Example.Monster.getRootAsMonster(fbb.dataBuffer()).unpack();
let monster_t = Monster.getRootAsMonster(fbb.dataBuffer()).unpack();
fbb.clear();
MyGame.Example.Monster.finishMonsterBuffer(fbb, monster_t.pack(fbb));
Monster.finishMonsterBuffer(fbb, monster_t.pack(fbb));
serializeAndTest(fbb);
}
@@ -143,15 +138,15 @@ function testObjApiUnpack(monster) {
assert.strictEqual(pos.y, 2);
assert.strictEqual(pos.z, 3);
assert.strictEqual(pos.test1, 3);
assert.strictEqual(pos.test2, MyGame.Example.Color.Green);
assert.strictEqual(pos.test2, Color.Green);
let test3 = pos.test3;
assert.strictEqual(test3.a, 5);
assert.strictEqual(test3.b, 6);
assert.strictEqual(monster.testType, MyGame.Example.Any.Monster);
assert.strictEqual(monster.testType, Any.Monster);
let monster2 = monster.test;
assert.strictEqual(monster2 != null, true);
assert.strictEqual(monster2 instanceof MyGame.Example.MonsterT, true);
assert.strictEqual(monster2 instanceof MonsterT, true);
assert.strictEqual(monster2.name, 'Fred');
assert.strictEqual(monster.inventory.length, 5);
@@ -174,9 +169,9 @@ function testObjApiUnpack(monster) {
}
function testBuffer(bb) {
assert.ok(MyGame.Example.Monster.bufferHasIdentifier(bb));
assert.ok(Monster.bufferHasIdentifier(bb));
var monster = MyGame.Example.Monster.getRootAsMonster(bb);
var monster = Monster.getRootAsMonster(bb);
assert.strictEqual(monster.hp(), 80);
assert.strictEqual(monster.mana(), 150); // default
@@ -188,13 +183,13 @@ function testBuffer(bb) {
assert.strictEqual(pos.y(), 2);
assert.strictEqual(pos.z(), 3);
assert.strictEqual(pos.test1(), 3);
assert.strictEqual(pos.test2(), MyGame.Example.Color.Green);
assert.strictEqual(pos.test2(), Color.Green);
var t = pos.test3();
assert.strictEqual(t.a(), 5);
assert.strictEqual(t.b(), 6);
assert.strictEqual(monster.testType(), MyGame.Example.Any.Monster);
var monster2 = new MyGame.Example.Monster();
assert.strictEqual(monster.testType(), Any.Monster);
var monster2 = new Monster();
assert.strictEqual(monster.test(monster2) != null, true);
assert.strictEqual(monster2.name(), 'Fred');
@@ -223,47 +218,45 @@ function testBuffer(bb) {
assert.strictEqual(monster.testbool(), true);
if(isTsTest) {
let monster_t = monster.unpack();
testObjApiUnpack(monster_t);
let monster_t = monster.unpack();
testObjApiUnpack(monster_t);
let monster2_t = new MyGame.Example.MonsterT();
monster.unpackTo(monster2_t);
testObjApiUnpack(monster2_t);
}
let monster2_t = new MonsterT();
monster.unpackTo(monster2_t);
testObjApiUnpack(monster2_t);
}
function test64bit() {
var fbb = new flatbuffers.Builder();
var required = fbb.createString('required');
MyGame.Example.Stat.startStat(fbb);
var stat2 = MyGame.Example.Stat.endStat(fbb);
Stat.startStat(fbb);
var stat2 = Stat.endStat(fbb);
MyGame.Example.Monster.startMonster(fbb);
MyGame.Example.Monster.addName(fbb, required);
MyGame.Example.Monster.addTestempty(fbb, stat2);
var mon2 = MyGame.Example.Monster.endMonster(fbb);
Monster.startMonster(fbb);
Monster.addName(fbb, required);
Monster.addTestempty(fbb, stat2);
var mon2 = Monster.endMonster(fbb);
MyGame.Example.Stat.startStat(fbb);
Stat.startStat(fbb);
// 2541551405100253985 = 0x87654321(low part) + 0x23456789 * 0x100000000(high part);
MyGame.Example.Stat.addVal(fbb, new flatbuffers.Long(0x87654321, 0x23456789)); // the low part is Uint32
var stat = MyGame.Example.Stat.endStat(fbb);
Stat.addVal(fbb, new flatbuffers.Long(0x87654321, 0x23456789)); // the low part is Uint32
var stat = Stat.endStat(fbb);
MyGame.Example.Monster.startMonster(fbb);
MyGame.Example.Monster.addName(fbb, required);
MyGame.Example.Monster.addEnemy(fbb, mon2);
MyGame.Example.Monster.addTestempty(fbb, stat);
var mon = MyGame.Example.Monster.endMonster(fbb);
Monster.startMonster(fbb);
Monster.addName(fbb, required);
Monster.addEnemy(fbb, mon2);
Monster.addTestempty(fbb, stat);
var mon = Monster.endMonster(fbb);
MyGame.Example.Monster.finishMonsterBuffer(fbb, mon);
Monster.finishMonsterBuffer(fbb, mon);
var bytes = fbb.asUint8Array();
////////////////////////////////////////////////////////////////
var bb = new flatbuffers.ByteBuffer(bytes);
assert.ok(MyGame.Example.Monster.bufferHasIdentifier(bb));
var mon = MyGame.Example.Monster.getRootAsMonster(bb);
assert.ok(Monster.bufferHasIdentifier(bb));
var mon = Monster.getRootAsMonster(bb);
var stat = mon.testempty();
assert.strictEqual(stat != null, true);
@@ -285,7 +278,7 @@ function testUnicode() {
// Test reading
function testReadingUnicode(bb) {
var monster = MyGame.Example.Monster.getRootAsMonster(bb);
var monster = Monster.getRootAsMonster(bb);
assert.strictEqual(monster.name(), json.name);
assert.deepEqual(new Buffer(monster.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(json.name));
assert.strictEqual(monster.testarrayoftablesLength(), json.testarrayoftables.length);
@@ -307,19 +300,19 @@ function testUnicode() {
var name = fbb.createString(json.name);
var testarrayoftablesOffsets = json.testarrayoftables.map(function(table) {
var name = fbb.createString(new Uint8Array(new Buffer(table.name)));
MyGame.Example.Monster.startMonster(fbb);
MyGame.Example.Monster.addName(fbb, name);
return MyGame.Example.Monster.endMonster(fbb);
Monster.startMonster(fbb);
Monster.addName(fbb, name);
return Monster.endMonster(fbb);
});
var testarrayoftablesOffset = MyGame.Example.Monster.createTestarrayoftablesVector(fbb,
var testarrayoftablesOffset = Monster.createTestarrayoftablesVector(fbb,
testarrayoftablesOffsets);
var testarrayofstringOffset = MyGame.Example.Monster.createTestarrayofstringVector(fbb,
var testarrayofstringOffset = Monster.createTestarrayofstringVector(fbb,
json.testarrayofstring.map(function(string) { return fbb.createString(string); }));
MyGame.Example.Monster.startMonster(fbb);
MyGame.Example.Monster.addTestarrayofstring(fbb, testarrayofstringOffset);
MyGame.Example.Monster.addTestarrayoftables(fbb, testarrayoftablesOffset);
MyGame.Example.Monster.addName(fbb, name);
MyGame.Example.Monster.finishSizePrefixedMonsterBuffer(fbb, MyGame.Example.Monster.endMonster(fbb));
Monster.startMonster(fbb);
Monster.addTestarrayofstring(fbb, testarrayofstringOffset);
Monster.addTestarrayoftables(fbb, testarrayoftablesOffset);
Monster.addName(fbb, name);
Monster.finishSizePrefixedMonsterBuffer(fbb, Monster.endMonster(fbb));
var bb = new flatbuffers.ByteBuffer(fbb.asUint8Array())
bb.setPosition(4);
testReadingUnicode(bb);

24
tests/JavaScriptTest.sh
View File

@@ -1,24 +0,0 @@
#!/bin/sh
#
# Copyright 2016 Google Inc. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
pushd "$(dirname $0)" >/dev/null
../flatc -b -I include_test monster_test.fbs unicode_test.json
../flatc --js -o js --gen-name-strings --gen-mutable --no-fb-import -I include_test monster_test.fbs
node JavaScriptTest ./js/monster_test_generated
../flatc --js --gen-name-strings -o js --no-fb-import union_vector/union_vector.fbs
node JavaScriptUnionVectorTest ./js/union_vector_generated
node JavaScriptFlexBuffersTest

116
tests/JavaScriptUnionVectorTest.js
View File

@@ -1,16 +1,17 @@
var assert = require('assert');
import assert from 'assert'
import * as flatbuffers from 'flatbuffers'
var flatbuffers = require('../js/flatbuffers').flatbuffers;
var Test = require(process.argv[2]);
var isTsTest = !!process.env.FB_TS_TEST;
import { Character } from './ts/character'
import { BookReader, BookReaderT } from './ts/book-reader'
import { Attacker, AttackerT } from './ts/attacker'
import { Movie, MovieT } from './ts/movie'
var charTypes = [
Test.Character.Belle,
Test.Character.MuLan,
Test.Character.BookFan,
Character.Belle,
Character.MuLan,
Character.BookFan,
Character.Other
];
if(isTsTest) { charTypes.push(Test.Character.Other); }
function testMovieBuf(movie) {
assert.strictEqual(movie.charactersTypeLength(), charTypes.length);
@@ -20,19 +21,17 @@ function testMovieBuf(movie) {
assert.strictEqual(movie.charactersType(i), charTypes[i]);
}
var bookReader7 = movie.characters(0, new Test.BookReader());
var bookReader7 = movie.characters(0, new BookReader());
assert.strictEqual(bookReader7.booksRead(), 7);
var attacker = movie.characters(1, new Test.Attacker());
var attacker = movie.characters(1, new Attacker());
assert.strictEqual(attacker.swordAttackDamage(), 5);
var bookReader2 = movie.characters(2, new Test.BookReader());
var bookReader2 = movie.characters(2, new BookReader());
assert.strictEqual(bookReader2.booksRead(), 2);
if(isTsTest) {
var other = movie.characters(3, '');
assert.strictEqual(other, "I am other");
}
var other = movie.characters(3, '');
assert.strictEqual(other, "I am other");
}
function testMovieUnpack(movie) {
@@ -44,58 +43,45 @@ function testMovieUnpack(movie) {
}
var bookReader7 = movie.characters[0];
assert.strictEqual(bookReader7 instanceof Test.BookReaderT, true);
assert.strictEqual(bookReader7 instanceof BookReaderT, true);
assert.strictEqual(bookReader7.booksRead, 7);
var attacker = movie.characters[1];
assert.strictEqual(attacker instanceof Test.AttackerT, true);
assert.strictEqual(attacker instanceof AttackerT, true);
assert.strictEqual(attacker.swordAttackDamage, 5);
var bookReader2 = movie.characters[2];
assert.strictEqual(bookReader2 instanceof Test.BookReaderT, true);
assert.strictEqual(bookReader2 instanceof BookReaderT, true);
assert.strictEqual(bookReader2.booksRead, 2);
if(isTsTest) {
var other = movie.characters[3];
assert.strictEqual(other, "I am other");
}
var other = movie.characters[3];
assert.strictEqual(other, "I am other");
}
function createMovie(fbb) {
Test.Attacker.startAttacker(fbb);
Test.Attacker.addSwordAttackDamage(fbb, 5);
var attackerOffset = Test.Attacker.endAttacker(fbb);
Attacker.startAttacker(fbb);
Attacker.addSwordAttackDamage(fbb, 5);
var attackerOffset = Attacker.endAttacker(fbb);
var charTypesOffset = Test.Movie.createCharactersTypeVector(fbb, charTypes);
var charTypesOffset = Movie.createCharactersTypeVector(fbb, charTypes);
var charsOffset = 0;
if(isTsTest) {
let otherOffset = fbb.createString("I am other");
let otherOffset = fbb.createString("I am other");
charsOffset = Test.Movie.createCharactersVector(
fbb,
[
Test.BookReader.createBookReader(fbb, 7),
attackerOffset,
Test.BookReader.createBookReader(fbb, 2),
otherOffset
]
);
} else {
charsOffset = Test.Movie.createCharactersVector(
fbb,
[
Test.BookReader.createBookReader(fbb, 7),
attackerOffset,
Test.BookReader.createBookReader(fbb, 2)
]
);
}
charsOffset = Movie.createCharactersVector(
fbb,
[
BookReader.createBookReader(fbb, 7),
attackerOffset,
BookReader.createBookReader(fbb, 2),
otherOffset
]
);
Test.Movie.startMovie(fbb);
Test.Movie.addCharactersType(fbb, charTypesOffset);
Test.Movie.addCharacters(fbb, charsOffset);
Test.Movie.finishMovieBuffer(fbb, Test.Movie.endMovie(fbb))
Movie.startMovie(fbb);
Movie.addCharactersType(fbb, charTypesOffset);
Movie.addCharacters(fbb, charsOffset);
Movie.finishMovieBuffer(fbb, Movie.endMovie(fbb))
}
function main() {
@@ -105,22 +91,20 @@ function main() {
var buf = new flatbuffers.ByteBuffer(fbb.asUint8Array());
var movie = Test.Movie.getRootAsMovie(buf);
var movie = Movie.getRootAsMovie(buf);
testMovieBuf(movie);
if(isTsTest) {
testMovieUnpack(movie.unpack());
testMovieUnpack(movie.unpack());
var movie_to = new Test.MovieT();
movie.unpackTo(movie_to);
testMovieUnpack(movie_to);
fbb.clear();
Test.Movie.finishMovieBuffer(fbb, movie_to.pack(fbb));
var unpackBuf = new flatbuffers.ByteBuffer(fbb.asUint8Array());
testMovieBuf(Test.Movie.getRootAsMovie(unpackBuf));
}
var movie_to = new MovieT();
movie.unpackTo(movie_to);
testMovieUnpack(movie_to);
fbb.clear();
Movie.finishMovieBuffer(fbb, movie_to.pack(fbb));
var unpackBuf = new flatbuffers.ByteBuffer(fbb.asUint8Array());
testMovieBuf(Movie.getRootAsMovie(unpackBuf));
console.log('FlatBuffers union vector test: completed successfully');
}

6
tests/TestAll.sh
View File

@@ -14,12 +14,6 @@ echo "************************ Python:"
sh PythonTest.sh
echo "************************ JavaScript:"
sh JavaScriptTest.sh
# FIXME does not exist:
# sh JavaScriptUnionVectorTest.sh
echo "************************ TypeScript:"
sh TypeScriptTest.sh

8
tests/TypeScriptTest.bat Executable file
View File

@@ -0,0 +1,8 @@
npm install
../flatc.exe --ts --gen-name-strings --gen-mutable --gen-object-api -o ts -I include_test monster_test.fbs
../flatc.exe --gen-object-api -b -I include_test monster_test.fbs unicode_test.json
../flatc.exe --ts --gen-name-strings --gen-object-api -o ts union_vector/union_vector.fbs
tsc
node -r esm JavaScriptTest
node -r esm JavaScriptUnionVectorTest
node -r esm JavaScriptFlexBuffersTest

24
tests/TypeScriptTest.sh
View File

@@ -16,20 +16,14 @@
pushd "$(dirname $0)" >/dev/null
npm install @types/flatbuffers
npm run pretest
# clean node_modules to make sure we depend on latest local flatbuffers at ../
rm -rf node_modules
npm install
export FB_TS_TEST="TRUE"
../flatc --ts --no-fb-import --gen-name-strings --gen-mutable --gen-object-api -o ts -I include_test monster_test.fbs
../flatc --ts --gen-name-strings --gen-mutable --gen-object-api -o ts -I include_test monster_test.fbs
../flatc --gen-object-api -b -I include_test monster_test.fbs unicode_test.json
tsc --strict --noUnusedParameters --noUnusedLocals --noImplicitReturns --strictNullChecks ts/monster_test_generated.ts
node JavaScriptTest ./ts/monster_test_generated
../flatc --ts --gen-name-strings --no-fb-import --gen-object-api -o ts union_vector/union_vector.fbs
tsc --strict --noUnusedParameters --noUnusedLocals --noImplicitReturns --strictNullChecks ts/union_vector_generated.ts
node JavaScriptUnionVectorTest ./ts/union_vector_generated
unset FB_TS_TEST
npm uninstall @types/flatbuffers
../flatc --ts --gen-name-strings --gen-object-api -o ts union_vector/union_vector.fbs
tsc
node -r esm JavaScriptTest
node -r esm JavaScriptUnionVectorTest
node -r esm JavaScriptFlexBuffersTest

10
tests/docker/languages/Dockerfile.testing.node.10_13_0
View File

@@ -1,10 +0,0 @@
FROM node:10.13.0-stretch as base
WORKDIR /code
ADD . .
RUN cp flatc_debian_stretch flatc
WORKDIR /code/tests
RUN node --version
RUN ../flatc -b -I include_test monster_test.fbs unicode_test.json
RUN npm install
RUN npm run pretest
RUN node JavaScriptTest ./monster_test_generated

10
tests/docker/languages/Dockerfile.testing.node.11_2_0
View File

@@ -1,10 +0,0 @@
FROM node:11.2.0-stretch as base
WORKDIR /code
ADD . .
RUN cp flatc_debian_stretch flatc
WORKDIR /code/tests
RUN node --version
RUN ../flatc -b -I include_test monster_test.fbs unicode_test.json
RUN npm install
RUN npm run pretest
RUN node JavaScriptTest ./monster_test_generated

6
tests/docker/languages/Dockerfile.testing.node.12_20_1 Normal file
View File

@@ -0,0 +1,6 @@
FROM node:12.20.1-stretch as base
WORKDIR /code
ADD . .
RUN cp flatc_debian_stretch flatc
RUN npm install
RUN npm test

6
tests/docker/languages/Dockerfile.testing.node.14_15_4 Normal file
View File

@@ -0,0 +1,6 @@
FROM node:14.15.4-stretch as base
WORKDIR /code
ADD . .
RUN cp flatc_debian_stretch flatc
RUN npm install
RUN npm test

12
tests/generate_code.bat
View File

@@ -32,18 +32,18 @@ set TEST_CS_FLAGS=--cs-gen-json-serializer
set TEST_JS_TS_FLAGS=--gen-name-strings
set TEST_RUST_FLAGS=--gen-name-strings
set TEST_BASE_FLAGS=--reflect-names --gen-mutable --gen-object-api
set TEST_NOINCL_FLAGS=%TEST_BASE_FLAGS% --no-includes --no-fb-import
set TEST_NOINCL_FLAGS=%TEST_BASE_FLAGS% --no-includes
..\%buildtype%\flatc.exe --binary --cpp --java --kotlin --csharp --dart --go --lobster --lua --js --ts --php --grpc ^
..\%buildtype%\flatc.exe --binary --cpp --java --kotlin --csharp --dart --go --lobster --lua --ts --php --grpc ^
%TEST_NOINCL_FLAGS% %TEST_CPP_FLAGS% %TEST_CS_FLAGS% -I include_test monster_test.fbs monsterdata_test.json || goto FAIL
..\%buildtype%\flatc.exe --rust %TEST_NOINCL_FLAGS% %TEST_RUST_FLAGS% -I include_test monster_test.fbs monsterdata_test.json || goto FAIL
..\%buildtype%\flatc.exe --python %TEST_BASE_FLAGS% --no-fb-import -I include_test monster_test.fbs monsterdata_test.json || goto FAIL
..\%buildtype%\flatc.exe --python %TEST_BASE_FLAGS% -I include_test monster_test.fbs monsterdata_test.json || goto FAIL
..\%buildtype%\flatc.exe --binary --cpp --java --csharp --dart --go --lobster --lua --js --ts --php --python --rust ^
..\%buildtype%\flatc.exe --binary --cpp --java --csharp --dart --go --lobster --lua --ts --php --python --rust ^
%TEST_NOINCL_FLAGS% %TEST_CPP_FLAGS% %TEST_CS_FLAGS% %TEST_JS_TS_FLAGS% -o namespace_test namespace_test/namespace_test1.fbs namespace_test/namespace_test2.fbs || goto FAIL
..\%buildtype%\flatc.exe --cpp --java --csharp --js --ts --php %TEST_BASE_FLAGS% %TEST_CPP_FLAGS% %TEST_CS_FLAGS% %TEST_JS_TS_FLAGS% -o union_vector ./union_vector/union_vector.fbs || goto FAIL
..\%buildtype%\flatc.exe --cpp --java --csharp --ts --php %TEST_BASE_FLAGS% %TEST_CPP_FLAGS% %TEST_CS_FLAGS% %TEST_JS_TS_FLAGS% -o union_vector ./union_vector/union_vector.fbs || goto FAIL
..\%buildtype%\flatc.exe --rust -I include_test -o include_test include_test/include_test1.fbs || goto FAIL
..\%buildtype%\flatc.exe --rust -I include_test -o include_test/sub include_test/sub/include_test2.fbs || goto FAIL
..\%buildtype%\flatc.exe -b --schema --bfbs-comments --bfbs-builtins -I include_test monster_test.fbs || goto FAIL
@@ -55,7 +55,7 @@ set TEST_NOINCL_FLAGS=%TEST_BASE_FLAGS% --no-includes --no-fb-import
..\%buildtype%\flatc.exe --cpp %TEST_BASE_FLAGS% --cpp-ptr-type flatbuffers::unique_ptr native_type_test.fbs || goto FAIL
@rem Generate the optional scalar code for tests.
..\%buildtype%\flatc.exe --java --kotlin --rust --lobster --ts --js optional_scalars.fbs || goto FAIL
..\%buildtype%\flatc.exe --java --kotlin --rust --lobster --ts optional_scalars.fbs || goto FAIL
..\%buildtype%\flatc.exe --csharp --gen-object-api optional_scalars.fbs || goto FAIL
..\%buildtype%\flatc.exe %TEST_NOINCL_FLAGS% %TEST_CPP_FLAGS% --cpp optional_scalars.fbs || goto FAIL

10
tests/generate_code.sh
View File

@@ -29,18 +29,18 @@ TEST_CS_FLAGS="--cs-gen-json-serializer"
TEST_JS_TS_FLAGS="--gen-name-strings"
TEST_BASE_FLAGS="--reflect-names --gen-mutable --gen-object-api"
TEST_RUST_FLAGS="$TEST_BASE_FLAGS --gen-name-strings"
TEST_NOINCL_FLAGS="$TEST_BASE_FLAGS --no-includes --no-fb-import"
TEST_NOINCL_FLAGS="$TEST_BASE_FLAGS --no-includes"
../flatc --binary --cpp --java --kotlin --csharp --dart --go --lobster --lua --js --ts --php --grpc \
../flatc --binary --cpp --java --kotlin --csharp --dart --go --lobster --lua --ts --php --grpc \
$TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS -I include_test monster_test.fbs monsterdata_test.json
../flatc --rust $TEST_RUST_FLAGS -I include_test monster_test.fbs monsterdata_test.json
../flatc --python $TEST_BASE_FLAGS -I include_test monster_test.fbs monsterdata_test.json
../flatc --cpp --java --kotlin --csharp --dart --go --binary --lobster --lua --js --ts --php --python --rust \
../flatc --cpp --java --kotlin --csharp --dart --go --binary --lobster --lua --ts --php --python --rust \
$TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o namespace_test namespace_test/namespace_test1.fbs namespace_test/namespace_test2.fbs
../flatc --cpp --java --kotlin --csharp --js --ts --php $TEST_BASE_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o union_vector ./union_vector/union_vector.fbs
../flatc --cpp --java --kotlin --csharp --ts --php $TEST_BASE_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o union_vector ./union_vector/union_vector.fbs
../flatc --rust -I include_test -o include_test include_test/include_test1.fbs
../flatc --rust -I include_test -o include_test/sub include_test/sub/include_test2.fbs
../flatc -b --schema --bfbs-comments --bfbs-builtins -I include_test monster_test.fbs
@@ -53,7 +53,7 @@ $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS $TEST_CS_FLAGS $TEST_JS_TS_FLAGS -o namespace
../flatc --dart monster_extra.fbs
# Generate optional scalar code for tests.
../flatc --java --kotlin --rust --lobster --ts --js optional_scalars.fbs
../flatc --java --kotlin --rust --lobster --ts optional_scalars.fbs
../flatc --csharp --gen-object-api optional_scalars.fbs
../flatc $TEST_NOINCL_FLAGS $TEST_CPP_FLAGS --cpp optional_scalars.fbs

92
tests/monster_test_grpc.d.ts vendored
View File

@@ -1,92 +0,0 @@
// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***
import { flatbuffers } from 'flatbuffers';
import * as MonsterStorage_fbs from './monster_test_generated';
import * as grpc from 'grpc';
interface IMonsterStorageService extends grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {
Store: IMonsterStorageService_IStore;
Retrieve: IMonsterStorageService_IRetrieve;
GetMaxHitPoint: IMonsterStorageService_IGetMaxHitPoint;
GetMinMaxHitPoints: IMonsterStorageService_IGetMinMaxHitPoints;
}
interface IMonsterStorageService_IStore extends grpc.MethodDefinition<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat> {
path: string; // /MyGame.Example.MonsterStorage/Store
requestStream: boolean; // false
responseStream: boolean; // false
requestSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
responseSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
}
interface IMonsterStorageService_IRetrieve extends grpc.MethodDefinition<MonsterStorage_fbs.Stat, MonsterStorage_fbs.Monster> {
path: string; // /MyGame.Example.MonsterStorage/Retrieve
requestStream: boolean; // false
responseStream: boolean; // true
requestSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
responseSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
}
interface IMonsterStorageService_IGetMaxHitPoint extends grpc.MethodDefinition<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat> {
path: string; // /MyGame.Example.MonsterStorage/GetMaxHitPoint
requestStream: boolean; // true
responseStream: boolean; // false
requestSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
responseSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
}
interface IMonsterStorageService_IGetMinMaxHitPoints extends grpc.MethodDefinition<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat> {
path: string; // /MyGame.Example.MonsterStorage/GetMinMaxHitPoints
requestStream: boolean; // true
responseStream: boolean; // true
requestSerialize: grpc.serialize<MonsterStorage_fbs.Monster>;
requestDeserialize: grpc.deserialize<MonsterStorage_fbs.Monster>;
responseSerialize: grpc.serialize<MonsterStorage_fbs.Stat>;
responseDeserialize: grpc.deserialize<MonsterStorage_fbs.Stat>;
}
export const MonsterStorageService: IMonsterStorageService;
export interface IMonsterStorageServer {
Store: grpc.handleUnaryCall<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
Retrieve: grpc.handleServerStreamingCall<MonsterStorage_fbs.Stat, MonsterStorage_fbs.Monster>;
GetMaxHitPoint: grpc.handleClientStreamingCall<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
GetMinMaxHitPoints: grpc.handleBidiStreamingCall<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
}
export interface IMonsterStorageClient {
Store(request: MonsterStorage_fbs.Monster, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
Retrieve(request: MonsterStorage_fbs.Stat, metadata: grpc.Metadata): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
Retrieve(request: MonsterStorage_fbs.Stat, options: Partial<grpc.CallOptions>): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
GetMaxHitPoint(callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
GetMaxHitPoint(metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
GetMaxHitPoint(options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
GetMaxHitPoint(metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
GetMinMaxHitPoints(): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
GetMinMaxHitPoints(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
GetMinMaxHitPoints(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
}
export class MonsterStorageClient extends grpc.Client implements IMonsterStorageClient {
constructor(address: string, credentials: grpc.ChannelCredentials, options?: object); public Store(request: MonsterStorage_fbs.Monster, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
public Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
public Store(request: MonsterStorage_fbs.Monster, metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Stat) => void): grpc.ClientUnaryCall;
public Retrieve(request: MonsterStorage_fbs.Stat, metadata: grpc.Metadata): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
public Retrieve(request: MonsterStorage_fbs.Stat, options: Partial<grpc.CallOptions>): grpc.ClientReadableStream<MonsterStorage_fbs.Monster>;
public GetMaxHitPoint(callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
public GetMaxHitPoint(metadata: grpc.Metadata, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
public GetMaxHitPoint(options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
public GetMaxHitPoint(metadata: grpc.Metadata, options: Partial<grpc.CallOptions>, callback: (error: grpc.ServiceError | null, response: MonsterStorage_fbs.Monster) => void): grpc.ClientWritableStream<MonsterStorage_fbs.Stat>;
public GetMinMaxHitPoints(): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
public GetMinMaxHitPoints(options: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
public GetMinMaxHitPoints(metadata: grpc.Metadata, options?: Partial<grpc.CallOptions>): grpc.ClientDuplexStream<MonsterStorage_fbs.Monster, MonsterStorage_fbs.Stat>;
}

79
tests/monster_test_grpc.js
View File

@@ -1,79 +0,0 @@
// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***
import { flatbuffers } from 'flatbuffers';
import * as MonsterStorage_fbs from './monster_test_generated';
var grpc = require('grpc');
function serialize_Stat(buffer_args) {
if (!(buffer_args instanceof MonsterStorage_fbs.Stat)) {
throw new Error('Expected argument of type MonsterStorage_fbs.Stat');
}
return buffer_args.serialize();
}
function deserialize_Stat(buffer) {
return MonsterStorage_fbs.Stat.getRootAsStat(new flatbuffers.ByteBuffer(buffer))
}
function serialize_Monster(buffer_args) {
if (!(buffer_args instanceof MonsterStorage_fbs.Monster)) {
throw new Error('Expected argument of type MonsterStorage_fbs.Monster');
}
return buffer_args.serialize();
}
function deserialize_Monster(buffer) {
return MonsterStorage_fbs.Monster.getRootAsMonster(new flatbuffers.ByteBuffer(buffer))
}
var MonsterStorageService = exports.MonsterStorageService = {
Store: {
path: '/MyGame.Example.MonsterStorage/Store',
requestStream: false,
responseStream: false,
requestType: flatbuffers.ByteBuffer,
responseType: MonsterStorage_fbs.Stat,
requestSerialize: serialize_Monster,
requestDeserialize: deserialize_Monster,
responseSerialize: serialize_Stat,
responseDeserialize: deserialize_Stat,
},
Retrieve: {
path: '/MyGame.Example.MonsterStorage/Retrieve',
requestStream: false,
responseStream: true,
requestType: flatbuffers.ByteBuffer,
responseType: MonsterStorage_fbs.Monster,
requestSerialize: serialize_Stat,
requestDeserialize: deserialize_Stat,
responseSerialize: serialize_Monster,
responseDeserialize: deserialize_Monster,
},
GetMaxHitPoint: {
path: '/MyGame.Example.MonsterStorage/GetMaxHitPoint',
requestStream: true,
responseStream: false,
requestType: flatbuffers.ByteBuffer,
responseType: MonsterStorage_fbs.Stat,
requestSerialize: serialize_Monster,
requestDeserialize: deserialize_Monster,
responseSerialize: serialize_Stat,
responseDeserialize: deserialize_Stat,
},
GetMinMaxHitPoints: {
path: '/MyGame.Example.MonsterStorage/GetMinMaxHitPoints',
requestStream: true,
responseStream: true,
requestType: flatbuffers.ByteBuffer,
responseType: MonsterStorage_fbs.Stat,
requestSerialize: serialize_Monster,
requestDeserialize: deserialize_Monster,
responseSerialize: serialize_Stat,
responseDeserialize: deserialize_Stat,
},
};
exports.MonsterStorageClient = grpc.makeGenericClientConstructor(MonsterStorageService);

782
tests/optional_scalars_generated.js
View File

@@ -1,782 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
/**
* @const
* @namespace
*/
var optional_scalars = optional_scalars || {};
/**
* @enum {number}
*/
optional_scalars.OptionalByte = {
None: 0,
One: 1,
Two: 2
};
/**
* @enum {string}
*/
optional_scalars.OptionalByteName = {
'0': 'None',
'1': 'One',
'2': 'Two'
};
/**
* @constructor
*/
optional_scalars.ScalarStuff = function() {
/**
* @type {flatbuffers.ByteBuffer}
*/
this.bb = null;
/**
* @type {number}
*/
this.bb_pos = 0;
};
/**
* @param {number} i
* @param {flatbuffers.ByteBuffer} bb
* @returns {optional_scalars.ScalarStuff}
*/
optional_scalars.ScalarStuff.prototype.__init = function(i, bb) {
this.bb_pos = i;
this.bb = bb;
return this;
};
/**
* @param {flatbuffers.ByteBuffer} bb
* @param {optional_scalars.ScalarStuff=} obj
* @returns {optional_scalars.ScalarStuff}
*/
optional_scalars.ScalarStuff.getRootAsScalarStuff = function(bb, obj) {
return (obj || new optional_scalars.ScalarStuff).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};
/**
* @param {flatbuffers.ByteBuffer} bb
* @param {optional_scalars.ScalarStuff=} obj
* @returns {optional_scalars.ScalarStuff}
*/
optional_scalars.ScalarStuff.getSizePrefixedRootAsScalarStuff = function(bb, obj) {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new optional_scalars.ScalarStuff).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};
/**
* @param {flatbuffers.ByteBuffer} bb
* @returns {boolean}
*/
optional_scalars.ScalarStuff.bufferHasIdentifier = function(bb) {
return bb.__has_identifier('NULL');
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justI8 = function() {
var offset = this.bb.__offset(this.bb_pos, 4);
return offset ? this.bb.readInt8(this.bb_pos + offset) : 0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeI8 = function() {
var offset = this.bb.__offset(this.bb_pos, 6);
return offset ? this.bb.readInt8(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultI8 = function() {
var offset = this.bb.__offset(this.bb_pos, 8);
return offset ? this.bb.readInt8(this.bb_pos + offset) : 42;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justU8 = function() {
var offset = this.bb.__offset(this.bb_pos, 10);
return offset ? this.bb.readUint8(this.bb_pos + offset) : 0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeU8 = function() {
var offset = this.bb.__offset(this.bb_pos, 12);
return offset ? this.bb.readUint8(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultU8 = function() {
var offset = this.bb.__offset(this.bb_pos, 14);
return offset ? this.bb.readUint8(this.bb_pos + offset) : 42;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justI16 = function() {
var offset = this.bb.__offset(this.bb_pos, 16);
return offset ? this.bb.readInt16(this.bb_pos + offset) : 0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeI16 = function() {
var offset = this.bb.__offset(this.bb_pos, 18);
return offset ? this.bb.readInt16(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultI16 = function() {
var offset = this.bb.__offset(this.bb_pos, 20);
return offset ? this.bb.readInt16(this.bb_pos + offset) : 42;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justU16 = function() {
var offset = this.bb.__offset(this.bb_pos, 22);
return offset ? this.bb.readUint16(this.bb_pos + offset) : 0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeU16 = function() {
var offset = this.bb.__offset(this.bb_pos, 24);
return offset ? this.bb.readUint16(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultU16 = function() {
var offset = this.bb.__offset(this.bb_pos, 26);
return offset ? this.bb.readUint16(this.bb_pos + offset) : 42;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justI32 = function() {
var offset = this.bb.__offset(this.bb_pos, 28);
return offset ? this.bb.readInt32(this.bb_pos + offset) : 0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeI32 = function() {
var offset = this.bb.__offset(this.bb_pos, 30);
return offset ? this.bb.readInt32(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultI32 = function() {
var offset = this.bb.__offset(this.bb_pos, 32);
return offset ? this.bb.readInt32(this.bb_pos + offset) : 42;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justU32 = function() {
var offset = this.bb.__offset(this.bb_pos, 34);
return offset ? this.bb.readUint32(this.bb_pos + offset) : 0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeU32 = function() {
var offset = this.bb.__offset(this.bb_pos, 36);
return offset ? this.bb.readUint32(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultU32 = function() {
var offset = this.bb.__offset(this.bb_pos, 38);
return offset ? this.bb.readUint32(this.bb_pos + offset) : 42;
};
/**
* @returns {flatbuffers.Long}
*/
optional_scalars.ScalarStuff.prototype.justI64 = function() {
var offset = this.bb.__offset(this.bb_pos, 40);
return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(0, 0);
};
/**
* @returns {flatbuffers.Long|null}
*/
optional_scalars.ScalarStuff.prototype.maybeI64 = function() {
var offset = this.bb.__offset(this.bb_pos, 42);
return offset ? this.bb.readInt64(this.bb_pos + offset) : null;
};
/**
* @returns {flatbuffers.Long}
*/
optional_scalars.ScalarStuff.prototype.defaultI64 = function() {
var offset = this.bb.__offset(this.bb_pos, 44);
return offset ? this.bb.readInt64(this.bb_pos + offset) : this.bb.createLong(42, 0);
};
/**
* @returns {flatbuffers.Long}
*/
optional_scalars.ScalarStuff.prototype.justU64 = function() {
var offset = this.bb.__offset(this.bb_pos, 46);
return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(0, 0);
};
/**
* @returns {flatbuffers.Long|null}
*/
optional_scalars.ScalarStuff.prototype.maybeU64 = function() {
var offset = this.bb.__offset(this.bb_pos, 48);
return offset ? this.bb.readUint64(this.bb_pos + offset) : null;
};
/**
* @returns {flatbuffers.Long}
*/
optional_scalars.ScalarStuff.prototype.defaultU64 = function() {
var offset = this.bb.__offset(this.bb_pos, 50);
return offset ? this.bb.readUint64(this.bb_pos + offset) : this.bb.createLong(42, 0);
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justF32 = function() {
var offset = this.bb.__offset(this.bb_pos, 52);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeF32 = function() {
var offset = this.bb.__offset(this.bb_pos, 54);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultF32 = function() {
var offset = this.bb.__offset(this.bb_pos, 56);
return offset ? this.bb.readFloat32(this.bb_pos + offset) : 42.0;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.justF64 = function() {
var offset = this.bb.__offset(this.bb_pos, 58);
return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0;
};
/**
* @returns {number|null}
*/
optional_scalars.ScalarStuff.prototype.maybeF64 = function() {
var offset = this.bb.__offset(this.bb_pos, 60);
return offset ? this.bb.readFloat64(this.bb_pos + offset) : null;
};
/**
* @returns {number}
*/
optional_scalars.ScalarStuff.prototype.defaultF64 = function() {
var offset = this.bb.__offset(this.bb_pos, 62);
return offset ? this.bb.readFloat64(this.bb_pos + offset) : 42.0;
};
/**
* @returns {boolean}
*/
optional_scalars.ScalarStuff.prototype.justBool = function() {
var offset = this.bb.__offset(this.bb_pos, 64);
return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false;
};
/**
* @returns {boolean|null}
*/
optional_scalars.ScalarStuff.prototype.maybeBool = function() {
var offset = this.bb.__offset(this.bb_pos, 66);
return offset ? !!this.bb.readInt8(this.bb_pos + offset) : null;
};
/**
* @returns {boolean}
*/
optional_scalars.ScalarStuff.prototype.defaultBool = function() {
var offset = this.bb.__offset(this.bb_pos, 68);
return offset ? !!this.bb.readInt8(this.bb_pos + offset) : true;
};
/**
* @returns {optional_scalars.OptionalByte}
*/
optional_scalars.ScalarStuff.prototype.justEnum = function() {
var offset = this.bb.__offset(this.bb_pos, 70);
return offset ? /** @type {optional_scalars.OptionalByte} */ (this.bb.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.None;
};
/**
* @returns {optional_scalars.OptionalByte|null}
*/
optional_scalars.ScalarStuff.prototype.maybeEnum = function() {
var offset = this.bb.__offset(this.bb_pos, 72);
return offset ? /** @type {optional_scalars.OptionalByte} */ (this.bb.readInt8(this.bb_pos + offset)) : null;
};
/**
* @returns {optional_scalars.OptionalByte}
*/
optional_scalars.ScalarStuff.prototype.defaultEnum = function() {
var offset = this.bb.__offset(this.bb_pos, 74);
return offset ? /** @type {optional_scalars.OptionalByte} */ (this.bb.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.One;
};
/**
* @param {flatbuffers.Builder} builder
*/
optional_scalars.ScalarStuff.startScalarStuff = function(builder) {
builder.startObject(36);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justI8
*/
optional_scalars.ScalarStuff.addJustI8 = function(builder, justI8) {
builder.addFieldInt8(0, justI8, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeI8
*/
optional_scalars.ScalarStuff.addMaybeI8 = function(builder, maybeI8) {
builder.addFieldInt8(1, maybeI8, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultI8
*/
optional_scalars.ScalarStuff.addDefaultI8 = function(builder, defaultI8) {
builder.addFieldInt8(2, defaultI8, 42);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justU8
*/
optional_scalars.ScalarStuff.addJustU8 = function(builder, justU8) {
builder.addFieldInt8(3, justU8, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeU8
*/
optional_scalars.ScalarStuff.addMaybeU8 = function(builder, maybeU8) {
builder.addFieldInt8(4, maybeU8, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultU8
*/
optional_scalars.ScalarStuff.addDefaultU8 = function(builder, defaultU8) {
builder.addFieldInt8(5, defaultU8, 42);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justI16
*/
optional_scalars.ScalarStuff.addJustI16 = function(builder, justI16) {
builder.addFieldInt16(6, justI16, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeI16
*/
optional_scalars.ScalarStuff.addMaybeI16 = function(builder, maybeI16) {
builder.addFieldInt16(7, maybeI16, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultI16
*/
optional_scalars.ScalarStuff.addDefaultI16 = function(builder, defaultI16) {
builder.addFieldInt16(8, defaultI16, 42);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justU16
*/
optional_scalars.ScalarStuff.addJustU16 = function(builder, justU16) {
builder.addFieldInt16(9, justU16, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeU16
*/
optional_scalars.ScalarStuff.addMaybeU16 = function(builder, maybeU16) {
builder.addFieldInt16(10, maybeU16, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultU16
*/
optional_scalars.ScalarStuff.addDefaultU16 = function(builder, defaultU16) {
builder.addFieldInt16(11, defaultU16, 42);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justI32
*/
optional_scalars.ScalarStuff.addJustI32 = function(builder, justI32) {
builder.addFieldInt32(12, justI32, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeI32
*/
optional_scalars.ScalarStuff.addMaybeI32 = function(builder, maybeI32) {
builder.addFieldInt32(13, maybeI32, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultI32
*/
optional_scalars.ScalarStuff.addDefaultI32 = function(builder, defaultI32) {
builder.addFieldInt32(14, defaultI32, 42);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justU32
*/
optional_scalars.ScalarStuff.addJustU32 = function(builder, justU32) {
builder.addFieldInt32(15, justU32, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeU32
*/
optional_scalars.ScalarStuff.addMaybeU32 = function(builder, maybeU32) {
builder.addFieldInt32(16, maybeU32, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultU32
*/
optional_scalars.ScalarStuff.addDefaultU32 = function(builder, defaultU32) {
builder.addFieldInt32(17, defaultU32, 42);
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Long} justI64
*/
optional_scalars.ScalarStuff.addJustI64 = function(builder, justI64) {
builder.addFieldInt64(18, justI64, builder.createLong(0, 0));
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Long} maybeI64
*/
optional_scalars.ScalarStuff.addMaybeI64 = function(builder, maybeI64) {
builder.addFieldInt64(19, maybeI64, builder.createLong(0, 0));
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Long} defaultI64
*/
optional_scalars.ScalarStuff.addDefaultI64 = function(builder, defaultI64) {
builder.addFieldInt64(20, defaultI64, builder.createLong(42, 0));
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Long} justU64
*/
optional_scalars.ScalarStuff.addJustU64 = function(builder, justU64) {
builder.addFieldInt64(21, justU64, builder.createLong(0, 0));
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Long} maybeU64
*/
optional_scalars.ScalarStuff.addMaybeU64 = function(builder, maybeU64) {
builder.addFieldInt64(22, maybeU64, builder.createLong(0, 0));
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Long} defaultU64
*/
optional_scalars.ScalarStuff.addDefaultU64 = function(builder, defaultU64) {
builder.addFieldInt64(23, defaultU64, builder.createLong(42, 0));
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justF32
*/
optional_scalars.ScalarStuff.addJustF32 = function(builder, justF32) {
builder.addFieldFloat32(24, justF32, 0.0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeF32
*/
optional_scalars.ScalarStuff.addMaybeF32 = function(builder, maybeF32) {
builder.addFieldFloat32(25, maybeF32, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultF32
*/
optional_scalars.ScalarStuff.addDefaultF32 = function(builder, defaultF32) {
builder.addFieldFloat32(26, defaultF32, 42.0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justF64
*/
optional_scalars.ScalarStuff.addJustF64 = function(builder, justF64) {
builder.addFieldFloat64(27, justF64, 0.0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} maybeF64
*/
optional_scalars.ScalarStuff.addMaybeF64 = function(builder, maybeF64) {
builder.addFieldFloat64(28, maybeF64, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} defaultF64
*/
optional_scalars.ScalarStuff.addDefaultF64 = function(builder, defaultF64) {
builder.addFieldFloat64(29, defaultF64, 42.0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {boolean} justBool
*/
optional_scalars.ScalarStuff.addJustBool = function(builder, justBool) {
builder.addFieldInt8(30, +justBool, +false);
};
/**
* @param {flatbuffers.Builder} builder
* @param {boolean} maybeBool
*/
optional_scalars.ScalarStuff.addMaybeBool = function(builder, maybeBool) {
builder.addFieldInt8(31, +maybeBool, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {boolean} defaultBool
*/
optional_scalars.ScalarStuff.addDefaultBool = function(builder, defaultBool) {
builder.addFieldInt8(32, +defaultBool, +true);
};
/**
* @param {flatbuffers.Builder} builder
* @param {optional_scalars.OptionalByte} justEnum
*/
optional_scalars.ScalarStuff.addJustEnum = function(builder, justEnum) {
builder.addFieldInt8(33, justEnum, optional_scalars.OptionalByte.None);
};
/**
* @param {flatbuffers.Builder} builder
* @param {optional_scalars.OptionalByte} maybeEnum
*/
optional_scalars.ScalarStuff.addMaybeEnum = function(builder, maybeEnum) {
builder.addFieldInt8(34, maybeEnum, 0);
};
/**
* @param {flatbuffers.Builder} builder
* @param {optional_scalars.OptionalByte} defaultEnum
*/
optional_scalars.ScalarStuff.addDefaultEnum = function(builder, defaultEnum) {
builder.addFieldInt8(35, defaultEnum, optional_scalars.OptionalByte.One);
};
/**
* @param {flatbuffers.Builder} builder
* @returns {flatbuffers.Offset}
*/
optional_scalars.ScalarStuff.endScalarStuff = function(builder) {
var offset = builder.endObject();
return offset;
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Offset} offset
*/
optional_scalars.ScalarStuff.finishScalarStuffBuffer = function(builder, offset) {
builder.finish(offset, 'NULL');
};
/**
* @param {flatbuffers.Builder} builder
* @param {flatbuffers.Offset} offset
*/
optional_scalars.ScalarStuff.finishSizePrefixedScalarStuffBuffer = function(builder, offset) {
builder.finish(offset, 'NULL', true);
};
/**
* @param {flatbuffers.Builder} builder
* @param {number} justI8
* @param {number|null} maybeI8
* @param {number} defaultI8
* @param {number} justU8
* @param {number|null} maybeU8
* @param {number} defaultU8
* @param {number} justI16
* @param {number|null} maybeI16
* @param {number} defaultI16
* @param {number} justU16
* @param {number|null} maybeU16
* @param {number} defaultU16
* @param {number} justI32
* @param {number|null} maybeI32
* @param {number} defaultI32
* @param {number} justU32
* @param {number|null} maybeU32
* @param {number} defaultU32
* @param {flatbuffers.Long} justI64
* @param {flatbuffers.Long|null} maybeI64
* @param {flatbuffers.Long} defaultI64
* @param {flatbuffers.Long} justU64
* @param {flatbuffers.Long|null} maybeU64
* @param {flatbuffers.Long} defaultU64
* @param {number} justF32
* @param {number|null} maybeF32
* @param {number} defaultF32
* @param {number} justF64
* @param {number|null} maybeF64
* @param {number} defaultF64
* @param {boolean} justBool
* @param {boolean|null} maybeBool
* @param {boolean} defaultBool
* @param {optional_scalars.OptionalByte} justEnum
* @param {optional_scalars.OptionalByte|null} maybeEnum
* @param {optional_scalars.OptionalByte} defaultEnum
* @returns {flatbuffers.Offset}
*/
optional_scalars.ScalarStuff.createScalarStuff = function(builder, justI8, maybeI8, defaultI8, justU8, maybeU8, defaultU8, justI16, maybeI16, defaultI16, justU16, maybeU16, defaultU16, justI32, maybeI32, defaultI32, justU32, maybeU32, defaultU32, justI64, maybeI64, defaultI64, justU64, maybeU64, defaultU64, justF32, maybeF32, defaultF32, justF64, maybeF64, defaultF64, justBool, maybeBool, defaultBool, justEnum, maybeEnum, defaultEnum) {
optional_scalars.ScalarStuff.startScalarStuff(builder);
optional_scalars.ScalarStuff.addJustI8(builder, justI8);
if (maybeI8 !== null)
optional_scalars.ScalarStuff.addMaybeI8(builder, maybeI8);
optional_scalars.ScalarStuff.addDefaultI8(builder, defaultI8);
optional_scalars.ScalarStuff.addJustU8(builder, justU8);
if (maybeU8 !== null)
optional_scalars.ScalarStuff.addMaybeU8(builder, maybeU8);
optional_scalars.ScalarStuff.addDefaultU8(builder, defaultU8);
optional_scalars.ScalarStuff.addJustI16(builder, justI16);
if (maybeI16 !== null)
optional_scalars.ScalarStuff.addMaybeI16(builder, maybeI16);
optional_scalars.ScalarStuff.addDefaultI16(builder, defaultI16);
optional_scalars.ScalarStuff.addJustU16(builder, justU16);
if (maybeU16 !== null)
optional_scalars.ScalarStuff.addMaybeU16(builder, maybeU16);
optional_scalars.ScalarStuff.addDefaultU16(builder, defaultU16);
optional_scalars.ScalarStuff.addJustI32(builder, justI32);
if (maybeI32 !== null)
optional_scalars.ScalarStuff.addMaybeI32(builder, maybeI32);
optional_scalars.ScalarStuff.addDefaultI32(builder, defaultI32);
optional_scalars.ScalarStuff.addJustU32(builder, justU32);
if (maybeU32 !== null)
optional_scalars.ScalarStuff.addMaybeU32(builder, maybeU32);
optional_scalars.ScalarStuff.addDefaultU32(builder, defaultU32);
optional_scalars.ScalarStuff.addJustI64(builder, justI64);
if (maybeI64 !== null)
optional_scalars.ScalarStuff.addMaybeI64(builder, maybeI64);
optional_scalars.ScalarStuff.addDefaultI64(builder, defaultI64);
optional_scalars.ScalarStuff.addJustU64(builder, justU64);
if (maybeU64 !== null)
optional_scalars.ScalarStuff.addMaybeU64(builder, maybeU64);
optional_scalars.ScalarStuff.addDefaultU64(builder, defaultU64);
optional_scalars.ScalarStuff.addJustF32(builder, justF32);
if (maybeF32 !== null)
optional_scalars.ScalarStuff.addMaybeF32(builder, maybeF32);
optional_scalars.ScalarStuff.addDefaultF32(builder, defaultF32);
optional_scalars.ScalarStuff.addJustF64(builder, justF64);
if (maybeF64 !== null)
optional_scalars.ScalarStuff.addMaybeF64(builder, maybeF64);
optional_scalars.ScalarStuff.addDefaultF64(builder, defaultF64);
optional_scalars.ScalarStuff.addJustBool(builder, justBool);
if (maybeBool !== null)
optional_scalars.ScalarStuff.addMaybeBool(builder, maybeBool);
optional_scalars.ScalarStuff.addDefaultBool(builder, defaultBool);
optional_scalars.ScalarStuff.addJustEnum(builder, justEnum);
if (maybeEnum !== null)
optional_scalars.ScalarStuff.addMaybeEnum(builder, maybeEnum);
optional_scalars.ScalarStuff.addDefaultEnum(builder, defaultEnum);
return optional_scalars.ScalarStuff.endScalarStuff(builder);
}
// Exports for Node.js and RequireJS
this.optional_scalars = optional_scalars;

722
tests/optional_scalars_generated.ts
View File

@@ -1,722 +0,0 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
/**
* @enum {number}
*/
export namespace optional_scalars{
export enum OptionalByte{
None= 0,
One= 1,
Two= 2
};
}
/**
* @constructor
*/
export namespace optional_scalars{
export class ScalarStuff {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos:number = 0;
/**
* @param number i
* @param flatbuffers.ByteBuffer bb
* @returns ScalarStuff
*/
__init(i:number, bb:flatbuffers.ByteBuffer):ScalarStuff {
this.bb_pos = i;
this.bb = bb;
return this;
};
/**
* @param flatbuffers.ByteBuffer bb
* @param ScalarStuff= obj
* @returns ScalarStuff
*/
static getRootAsScalarStuff(bb:flatbuffers.ByteBuffer, obj?:ScalarStuff):ScalarStuff {
return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};
/**
* @param flatbuffers.ByteBuffer bb
* @param ScalarStuff= obj
* @returns ScalarStuff
*/
static getSizePrefixedRootAsScalarStuff(bb:flatbuffers.ByteBuffer, obj?:ScalarStuff):ScalarStuff {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
};
/**
* @param flatbuffers.ByteBuffer bb
* @returns boolean
*/
static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {
return bb.__has_identifier('NULL');
};
/**
* @returns number
*/
justI8():number {
var offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.readInt8(this.bb_pos + offset) : 0;
};
/**
* @returns number|null
*/
maybeI8():number|null {
var offset = this.bb!.__offset(this.bb_pos, 6);
return offset ? this.bb!.readInt8(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultI8():number {
var offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? this.bb!.readInt8(this.bb_pos + offset) : 42;
};
/**
* @returns number
*/
justU8():number {
var offset = this.bb!.__offset(this.bb_pos, 10);
return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0;
};
/**
* @returns number|null
*/
maybeU8():number|null {
var offset = this.bb!.__offset(this.bb_pos, 12);
return offset ? this.bb!.readUint8(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultU8():number {
var offset = this.bb!.__offset(this.bb_pos, 14);
return offset ? this.bb!.readUint8(this.bb_pos + offset) : 42;
};
/**
* @returns number
*/
justI16():number {
var offset = this.bb!.__offset(this.bb_pos, 16);
return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0;
};
/**
* @returns number|null
*/
maybeI16():number|null {
var offset = this.bb!.__offset(this.bb_pos, 18);
return offset ? this.bb!.readInt16(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultI16():number {
var offset = this.bb!.__offset(this.bb_pos, 20);
return offset ? this.bb!.readInt16(this.bb_pos + offset) : 42;
};
/**
* @returns number
*/
justU16():number {
var offset = this.bb!.__offset(this.bb_pos, 22);
return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0;
};
/**
* @returns number|null
*/
maybeU16():number|null {
var offset = this.bb!.__offset(this.bb_pos, 24);
return offset ? this.bb!.readUint16(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultU16():number {
var offset = this.bb!.__offset(this.bb_pos, 26);
return offset ? this.bb!.readUint16(this.bb_pos + offset) : 42;
};
/**
* @returns number
*/
justI32():number {
var offset = this.bb!.__offset(this.bb_pos, 28);
return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;
};
/**
* @returns number|null
*/
maybeI32():number|null {
var offset = this.bb!.__offset(this.bb_pos, 30);
return offset ? this.bb!.readInt32(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultI32():number {
var offset = this.bb!.__offset(this.bb_pos, 32);
return offset ? this.bb!.readInt32(this.bb_pos + offset) : 42;
};
/**
* @returns number
*/
justU32():number {
var offset = this.bb!.__offset(this.bb_pos, 34);
return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
};
/**
* @returns number|null
*/
maybeU32():number|null {
var offset = this.bb!.__offset(this.bb_pos, 36);
return offset ? this.bb!.readUint32(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultU32():number {
var offset = this.bb!.__offset(this.bb_pos, 38);
return offset ? this.bb!.readUint32(this.bb_pos + offset) : 42;
};
/**
* @returns flatbuffers.Long
*/
justI64():flatbuffers.Long {
var offset = this.bb!.__offset(this.bb_pos, 40);
return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);
};
/**
* @returns flatbuffers.Long|null
*/
maybeI64():flatbuffers.Long|null {
var offset = this.bb!.__offset(this.bb_pos, 42);
return offset ? this.bb!.readInt64(this.bb_pos + offset) : null;
};
/**
* @returns flatbuffers.Long
*/
defaultI64():flatbuffers.Long {
var offset = this.bb!.__offset(this.bb_pos, 44);
return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(42, 0);
};
/**
* @returns flatbuffers.Long
*/
justU64():flatbuffers.Long {
var offset = this.bb!.__offset(this.bb_pos, 46);
return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(0, 0);
};
/**
* @returns flatbuffers.Long|null
*/
maybeU64():flatbuffers.Long|null {
var offset = this.bb!.__offset(this.bb_pos, 48);
return offset ? this.bb!.readUint64(this.bb_pos + offset) : null;
};
/**
* @returns flatbuffers.Long
*/
defaultU64():flatbuffers.Long {
var offset = this.bb!.__offset(this.bb_pos, 50);
return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(42, 0);
};
/**
* @returns number
*/
justF32():number {
var offset = this.bb!.__offset(this.bb_pos, 52);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0;
};
/**
* @returns number|null
*/
maybeF32():number|null {
var offset = this.bb!.__offset(this.bb_pos, 54);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultF32():number {
var offset = this.bb!.__offset(this.bb_pos, 56);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 42.0;
};
/**
* @returns number
*/
justF64():number {
var offset = this.bb!.__offset(this.bb_pos, 58);
return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0;
};
/**
* @returns number|null
*/
maybeF64():number|null {
var offset = this.bb!.__offset(this.bb_pos, 60);
return offset ? this.bb!.readFloat64(this.bb_pos + offset) : null;
};
/**
* @returns number
*/
defaultF64():number {
var offset = this.bb!.__offset(this.bb_pos, 62);
return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 42.0;
};
/**
* @returns boolean
*/
justBool():boolean {
var offset = this.bb!.__offset(this.bb_pos, 64);
return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false;
};
/**
* @returns boolean|null
*/
maybeBool():boolean|null {
var offset = this.bb!.__offset(this.bb_pos, 66);
return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null;
};
/**
* @returns boolean
*/
defaultBool():boolean {
var offset = this.bb!.__offset(this.bb_pos, 68);
return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : true;
};
/**
* @returns optional_scalars.OptionalByte
*/
justEnum():optional_scalars.OptionalByte {
var offset = this.bb!.__offset(this.bb_pos, 70);
return offset ? /** */ (this.bb!.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.None;
};
/**
* @returns optional_scalars.OptionalByte|null
*/
maybeEnum():optional_scalars.OptionalByte|null {
var offset = this.bb!.__offset(this.bb_pos, 72);
return offset ? /** */ (this.bb!.readInt8(this.bb_pos + offset)) : null;
};
/**
* @returns optional_scalars.OptionalByte
*/
defaultEnum():optional_scalars.OptionalByte {
var offset = this.bb!.__offset(this.bb_pos, 74);
return offset ? /** */ (this.bb!.readInt8(this.bb_pos + offset)) : optional_scalars.OptionalByte.One;
};
/**
* @param flatbuffers.Builder builder
*/
static startScalarStuff(builder:flatbuffers.Builder) {
builder.startObject(36);
};
/**
* @param flatbuffers.Builder builder
* @param number justI8
*/
static addJustI8(builder:flatbuffers.Builder, justI8:number) {
builder.addFieldInt8(0, justI8, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeI8
*/
static addMaybeI8(builder:flatbuffers.Builder, maybeI8:number) {
builder.addFieldInt8(1, maybeI8, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultI8
*/
static addDefaultI8(builder:flatbuffers.Builder, defaultI8:number) {
builder.addFieldInt8(2, defaultI8, 42);
};
/**
* @param flatbuffers.Builder builder
* @param number justU8
*/
static addJustU8(builder:flatbuffers.Builder, justU8:number) {
builder.addFieldInt8(3, justU8, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeU8
*/
static addMaybeU8(builder:flatbuffers.Builder, maybeU8:number) {
builder.addFieldInt8(4, maybeU8, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultU8
*/
static addDefaultU8(builder:flatbuffers.Builder, defaultU8:number) {
builder.addFieldInt8(5, defaultU8, 42);
};
/**
* @param flatbuffers.Builder builder
* @param number justI16
*/
static addJustI16(builder:flatbuffers.Builder, justI16:number) {
builder.addFieldInt16(6, justI16, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeI16
*/
static addMaybeI16(builder:flatbuffers.Builder, maybeI16:number) {
builder.addFieldInt16(7, maybeI16, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultI16
*/
static addDefaultI16(builder:flatbuffers.Builder, defaultI16:number) {
builder.addFieldInt16(8, defaultI16, 42);
};
/**
* @param flatbuffers.Builder builder
* @param number justU16
*/
static addJustU16(builder:flatbuffers.Builder, justU16:number) {
builder.addFieldInt16(9, justU16, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeU16
*/
static addMaybeU16(builder:flatbuffers.Builder, maybeU16:number) {
builder.addFieldInt16(10, maybeU16, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultU16
*/
static addDefaultU16(builder:flatbuffers.Builder, defaultU16:number) {
builder.addFieldInt16(11, defaultU16, 42);
};
/**
* @param flatbuffers.Builder builder
* @param number justI32
*/
static addJustI32(builder:flatbuffers.Builder, justI32:number) {
builder.addFieldInt32(12, justI32, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeI32
*/
static addMaybeI32(builder:flatbuffers.Builder, maybeI32:number) {
builder.addFieldInt32(13, maybeI32, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultI32
*/
static addDefaultI32(builder:flatbuffers.Builder, defaultI32:number) {
builder.addFieldInt32(14, defaultI32, 42);
};
/**
* @param flatbuffers.Builder builder
* @param number justU32
*/
static addJustU32(builder:flatbuffers.Builder, justU32:number) {
builder.addFieldInt32(15, justU32, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeU32
*/
static addMaybeU32(builder:flatbuffers.Builder, maybeU32:number) {
builder.addFieldInt32(16, maybeU32, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultU32
*/
static addDefaultU32(builder:flatbuffers.Builder, defaultU32:number) {
builder.addFieldInt32(17, defaultU32, 42);
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long justI64
*/
static addJustI64(builder:flatbuffers.Builder, justI64:flatbuffers.Long) {
builder.addFieldInt64(18, justI64, builder.createLong(0, 0));
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long maybeI64
*/
static addMaybeI64(builder:flatbuffers.Builder, maybeI64:flatbuffers.Long) {
builder.addFieldInt64(19, maybeI64, builder.createLong(0, 0));
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long defaultI64
*/
static addDefaultI64(builder:flatbuffers.Builder, defaultI64:flatbuffers.Long) {
builder.addFieldInt64(20, defaultI64, builder.createLong(42, 0));
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long justU64
*/
static addJustU64(builder:flatbuffers.Builder, justU64:flatbuffers.Long) {
builder.addFieldInt64(21, justU64, builder.createLong(0, 0));
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long maybeU64
*/
static addMaybeU64(builder:flatbuffers.Builder, maybeU64:flatbuffers.Long) {
builder.addFieldInt64(22, maybeU64, builder.createLong(0, 0));
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Long defaultU64
*/
static addDefaultU64(builder:flatbuffers.Builder, defaultU64:flatbuffers.Long) {
builder.addFieldInt64(23, defaultU64, builder.createLong(42, 0));
};
/**
* @param flatbuffers.Builder builder
* @param number justF32
*/
static addJustF32(builder:flatbuffers.Builder, justF32:number) {
builder.addFieldFloat32(24, justF32, 0.0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeF32
*/
static addMaybeF32(builder:flatbuffers.Builder, maybeF32:number) {
builder.addFieldFloat32(25, maybeF32, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultF32
*/
static addDefaultF32(builder:flatbuffers.Builder, defaultF32:number) {
builder.addFieldFloat32(26, defaultF32, 42.0);
};
/**
* @param flatbuffers.Builder builder
* @param number justF64
*/
static addJustF64(builder:flatbuffers.Builder, justF64:number) {
builder.addFieldFloat64(27, justF64, 0.0);
};
/**
* @param flatbuffers.Builder builder
* @param number maybeF64
*/
static addMaybeF64(builder:flatbuffers.Builder, maybeF64:number) {
builder.addFieldFloat64(28, maybeF64, 0);
};
/**
* @param flatbuffers.Builder builder
* @param number defaultF64
*/
static addDefaultF64(builder:flatbuffers.Builder, defaultF64:number) {
builder.addFieldFloat64(29, defaultF64, 42.0);
};
/**
* @param flatbuffers.Builder builder
* @param boolean justBool
*/
static addJustBool(builder:flatbuffers.Builder, justBool:boolean) {
builder.addFieldInt8(30, +justBool, +false);
};
/**
* @param flatbuffers.Builder builder
* @param boolean maybeBool
*/
static addMaybeBool(builder:flatbuffers.Builder, maybeBool:boolean) {
builder.addFieldInt8(31, +maybeBool, 0);
};
/**
* @param flatbuffers.Builder builder
* @param boolean defaultBool
*/
static addDefaultBool(builder:flatbuffers.Builder, defaultBool:boolean) {
builder.addFieldInt8(32, +defaultBool, +true);
};
/**
* @param flatbuffers.Builder builder
* @param optional_scalars.OptionalByte justEnum
*/
static addJustEnum(builder:flatbuffers.Builder, justEnum:optional_scalars.OptionalByte) {
builder.addFieldInt8(33, justEnum, optional_scalars.OptionalByte.None);
};
/**
* @param flatbuffers.Builder builder
* @param optional_scalars.OptionalByte maybeEnum
*/
static addMaybeEnum(builder:flatbuffers.Builder, maybeEnum:optional_scalars.OptionalByte) {
builder.addFieldInt8(34, maybeEnum, 0);
};
/**
* @param flatbuffers.Builder builder
* @param optional_scalars.OptionalByte defaultEnum
*/
static addDefaultEnum(builder:flatbuffers.Builder, defaultEnum:optional_scalars.OptionalByte) {
builder.addFieldInt8(35, defaultEnum, optional_scalars.OptionalByte.One);
};
/**
* @param flatbuffers.Builder builder
* @returns flatbuffers.Offset
*/
static endScalarStuff(builder:flatbuffers.Builder):flatbuffers.Offset {
var offset = builder.endObject();
return offset;
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset offset
*/
static finishScalarStuffBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
builder.finish(offset, 'NULL');
};
/**
* @param flatbuffers.Builder builder
* @param flatbuffers.Offset offset
*/
static finishSizePrefixedScalarStuffBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
builder.finish(offset, 'NULL', true);
};
static createScalarStuff(builder:flatbuffers.Builder, justI8:number, maybeI8:number|null, defaultI8:number, justU8:number, maybeU8:number|null, defaultU8:number, justI16:number, maybeI16:number|null, defaultI16:number, justU16:number, maybeU16:number|null, defaultU16:number, justI32:number, maybeI32:number|null, defaultI32:number, justU32:number, maybeU32:number|null, defaultU32:number, justI64:flatbuffers.Long, maybeI64:flatbuffers.Long|null, defaultI64:flatbuffers.Long, justU64:flatbuffers.Long, maybeU64:flatbuffers.Long|null, defaultU64:flatbuffers.Long, justF32:number, maybeF32:number|null, defaultF32:number, justF64:number, maybeF64:number|null, defaultF64:number, justBool:boolean, maybeBool:boolean|null, defaultBool:boolean, justEnum:optional_scalars.OptionalByte, maybeEnum:optional_scalars.OptionalByte|null, defaultEnum:optional_scalars.OptionalByte):flatbuffers.Offset {
ScalarStuff.startScalarStuff(builder);
ScalarStuff.addJustI8(builder, justI8);
if (maybeI8 !== null)
ScalarStuff.addMaybeI8(builder, maybeI8);
ScalarStuff.addDefaultI8(builder, defaultI8);
ScalarStuff.addJustU8(builder, justU8);
if (maybeU8 !== null)
ScalarStuff.addMaybeU8(builder, maybeU8);
ScalarStuff.addDefaultU8(builder, defaultU8);
ScalarStuff.addJustI16(builder, justI16);
if (maybeI16 !== null)
ScalarStuff.addMaybeI16(builder, maybeI16);
ScalarStuff.addDefaultI16(builder, defaultI16);
ScalarStuff.addJustU16(builder, justU16);
if (maybeU16 !== null)
ScalarStuff.addMaybeU16(builder, maybeU16);
ScalarStuff.addDefaultU16(builder, defaultU16);
ScalarStuff.addJustI32(builder, justI32);
if (maybeI32 !== null)
ScalarStuff.addMaybeI32(builder, maybeI32);
ScalarStuff.addDefaultI32(builder, defaultI32);
ScalarStuff.addJustU32(builder, justU32);
if (maybeU32 !== null)
ScalarStuff.addMaybeU32(builder, maybeU32);
ScalarStuff.addDefaultU32(builder, defaultU32);
ScalarStuff.addJustI64(builder, justI64);
if (maybeI64 !== null)
ScalarStuff.addMaybeI64(builder, maybeI64);
ScalarStuff.addDefaultI64(builder, defaultI64);
ScalarStuff.addJustU64(builder, justU64);
if (maybeU64 !== null)
ScalarStuff.addMaybeU64(builder, maybeU64);
ScalarStuff.addDefaultU64(builder, defaultU64);
ScalarStuff.addJustF32(builder, justF32);
if (maybeF32 !== null)
ScalarStuff.addMaybeF32(builder, maybeF32);
ScalarStuff.addDefaultF32(builder, defaultF32);
ScalarStuff.addJustF64(builder, justF64);
if (maybeF64 !== null)
ScalarStuff.addMaybeF64(builder, maybeF64);
ScalarStuff.addDefaultF64(builder, defaultF64);
ScalarStuff.addJustBool(builder, justBool);
if (maybeBool !== null)
ScalarStuff.addMaybeBool(builder, maybeBool);
ScalarStuff.addDefaultBool(builder, defaultBool);
ScalarStuff.addJustEnum(builder, justEnum);
if (maybeEnum !== null)
ScalarStuff.addMaybeEnum(builder, maybeEnum);
ScalarStuff.addDefaultEnum(builder, defaultEnum);
return ScalarStuff.endScalarStuff(builder);
}
}
}

6
tests/package.json Normal file
View File

@@ -0,0 +1,6 @@
{
"dependencies": {
"esm": "^3.2.25",
"flatbuffers": "../"
}
}

76
tests/ts/attacker.ts Normal file
View File

@@ -0,0 +1,76 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class Attacker {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Attacker {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsAttacker(bb:flatbuffers.ByteBuffer, obj?:Attacker):Attacker {
return (obj || new Attacker()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsAttacker(bb:flatbuffers.ByteBuffer, obj?:Attacker):Attacker {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Attacker()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
swordAttackDamage():number {
const offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;
}
static getFullyQualifiedName():string {
return 'Attacker';
}
static startAttacker(builder:flatbuffers.Builder) {
builder.startObject(1);
}
static addSwordAttackDamage(builder:flatbuffers.Builder, swordAttackDamage:number) {
builder.addFieldInt32(0, swordAttackDamage, 0);
}
static endAttacker(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static createAttacker(builder:flatbuffers.Builder, swordAttackDamage:number):flatbuffers.Offset {
Attacker.startAttacker(builder);
Attacker.addSwordAttackDamage(builder, swordAttackDamage);
return Attacker.endAttacker(builder);
}
unpack(): AttackerT {
return new AttackerT(
this.swordAttackDamage()
);
}
unpackTo(_o: AttackerT): void {
_o.swordAttackDamage = this.swordAttackDamage();
}
}
export class AttackerT {
constructor(
public swordAttackDamage: number = 0
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return Attacker.createAttacker(builder,
this.swordAttackDamage
);
}
}

58
tests/ts/book-reader.ts Normal file
View File

@@ -0,0 +1,58 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class BookReader {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):BookReader {
this.bb_pos = i;
this.bb = bb;
return this;
}
booksRead():number {
return this.bb!.readInt32(this.bb_pos);
}
static getFullyQualifiedName():string {
return 'BookReader';
}
static sizeOf():number {
return 4;
}
static createBookReader(builder:flatbuffers.Builder, books_read: number):flatbuffers.Offset {
builder.prep(4, 4);
builder.writeInt32(books_read);
return builder.offset();
}
unpack(): BookReaderT {
return new BookReaderT(
this.booksRead()
);
}
unpackTo(_o: BookReaderT): void {
_o.booksRead = this.booksRead();
}
}
export class BookReaderT {
constructor(
public booksRead: number = 0
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return BookReader.createBookReader(builder,
this.booksRead
);
}
}

50
tests/ts/character.ts Normal file
View File

@@ -0,0 +1,50 @@
// automatically generated by the FlatBuffers compiler, do not modify
import { Attacker, AttackerT } from './attacker';
import { BookReader, BookReaderT } from './book-reader';
import { Rapunzel, RapunzelT } from './rapunzel';
export enum Character{
NONE = 0,
MuLan = 1,
Rapunzel = 2,
Belle = 3,
BookFan = 4,
Other = 5,
Unused = 6
}
export function unionToCharacter(
type: Character,
accessor: (obj:Attacker|BookReader|Rapunzel|string) => Attacker|BookReader|Rapunzel|string|null
): Attacker|BookReader|Rapunzel|string|null {
switch(Character[type]) {
case 'NONE': return null;
case 'MuLan': return accessor(new Attacker())! as Attacker;
case 'Rapunzel': return accessor(new Rapunzel())! as Rapunzel;
case 'Belle': return accessor(new BookReader())! as BookReader;
case 'BookFan': return accessor(new BookReader())! as BookReader;
case 'Other': return accessor('') as string;
case 'Unused': return accessor('') as string;
default: return null;
}
}
export function unionListToCharacter(
type: Character,
accessor: (index: number, obj:Attacker|BookReader|Rapunzel|string) => Attacker|BookReader|Rapunzel|string|null,
index: number
): Attacker|BookReader|Rapunzel|string|null {
switch(Character[type]) {
case 'NONE': return null;
case 'MuLan': return accessor(index, new Attacker())! as Attacker;
case 'Rapunzel': return accessor(index, new Rapunzel())! as Rapunzel;
case 'Belle': return accessor(index, new BookReader())! as BookReader;
case 'BookFan': return accessor(index, new BookReader())! as BookReader;
case 'Other': return accessor(index, '') as string;
case 'Unused': return accessor(index, '') as string;
default: return null;
}
}

211
tests/ts/movie.ts Normal file
View File

@@ -0,0 +1,211 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
import { Attacker, AttackerT } from './attacker';
import { BookReader, BookReaderT } from './book-reader';
import { Character, unionToCharacter, unionListToCharacter } from './character';
import { Rapunzel, RapunzelT } from './rapunzel';
export class Movie {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Movie {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsMovie(bb:flatbuffers.ByteBuffer, obj?:Movie):Movie {
return (obj || new Movie()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsMovie(bb:flatbuffers.ByteBuffer, obj?:Movie):Movie {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Movie()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean {
return bb.__has_identifier('MOVI');
}
mainCharacterType():Character {
const offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.readUint8(this.bb_pos + offset) : Character.NONE;
}
mainCharacter<T extends flatbuffers.Table>(obj:any|string):any|string|null {
const offset = this.bb!.__offset(this.bb_pos, 6);
return offset ? this.bb!.__union_with_string(obj, this.bb_pos + offset) : null;
}
charactersType(index: number):Character|null {
const offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
}
charactersTypeLength():number {
const offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
}
charactersTypeArray():Uint8Array|null {
const offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
}
characters(index: number, obj:any|string):any|string|null {
const offset = this.bb!.__offset(this.bb_pos, 10);
return offset ? this.bb!.__union_with_string(obj, this.bb!.__vector(this.bb_pos + offset) + index * 4) : null;
}
charactersLength():number {
const offset = this.bb!.__offset(this.bb_pos, 10);
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
}
static getFullyQualifiedName():string {
return 'Movie';
}
static startMovie(builder:flatbuffers.Builder) {
builder.startObject(4);
}
static addMainCharacterType(builder:flatbuffers.Builder, mainCharacterType:Character) {
builder.addFieldInt8(0, mainCharacterType, Character.NONE);
}
static addMainCharacter(builder:flatbuffers.Builder, mainCharacterOffset:flatbuffers.Offset) {
builder.addFieldOffset(1, mainCharacterOffset, 0);
}
static addCharactersType(builder:flatbuffers.Builder, charactersTypeOffset:flatbuffers.Offset) {
builder.addFieldOffset(2, charactersTypeOffset, 0);
}
static createCharactersTypeVector(builder:flatbuffers.Builder, data:Character[]):flatbuffers.Offset {
builder.startVector(1, data.length, 1);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt8(data[i]);
}
return builder.endVector();
}
static startCharactersTypeVector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(1, numElems, 1);
}
static addCharacters(builder:flatbuffers.Builder, charactersOffset:flatbuffers.Offset) {
builder.addFieldOffset(3, charactersOffset, 0);
}
static createCharactersVector(builder:flatbuffers.Builder, data:flatbuffers.Offset[]):flatbuffers.Offset {
builder.startVector(4, data.length, 4);
for (let i = data.length - 1; i >= 0; i--) {
builder.addOffset(data[i]);
}
return builder.endVector();
}
static startCharactersVector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(4, numElems, 4);
}
static endMovie(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static finishMovieBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
builder.finish(offset, 'MOVI');
}
static finishSizePrefixedMovieBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) {
builder.finish(offset, 'MOVI', true);
}
static createMovie(builder:flatbuffers.Builder, mainCharacterType:Character, mainCharacterOffset:flatbuffers.Offset, charactersTypeOffset:flatbuffers.Offset, charactersOffset:flatbuffers.Offset):flatbuffers.Offset {
Movie.startMovie(builder);
Movie.addMainCharacterType(builder, mainCharacterType);
Movie.addMainCharacter(builder, mainCharacterOffset);
Movie.addCharactersType(builder, charactersTypeOffset);
Movie.addCharacters(builder, charactersOffset);
return Movie.endMovie(builder);
}
unpack(): MovieT {
return new MovieT(
this.mainCharacterType(),
(() => {
let temp = unionToCharacter(this.mainCharacterType(), this.mainCharacter.bind(this));
if(temp === null) { return null; }
if(typeof temp === 'string') { return temp; }
return temp.unpack()
})(),
this.bb!.createScalarList(this.charactersType.bind(this), this.charactersTypeLength()),
(() => {
let ret = [];
for(let targetEnumIndex = 0; targetEnumIndex < this.charactersTypeLength(); ++targetEnumIndex) {
let targetEnum = this.charactersType(targetEnumIndex);
if(targetEnum === null || Character[targetEnum!] === 'NONE') { continue; }
let temp = unionListToCharacter(targetEnum, this.characters.bind(this), targetEnumIndex);
if(temp === null) { continue; }
if(typeof temp === 'string') { ret.push(temp); continue; }
ret.push(temp.unpack());
}
return ret;
})()
);
}
unpackTo(_o: MovieT): void {
_o.mainCharacterType = this.mainCharacterType();
_o.mainCharacter = (() => {
let temp = unionToCharacter(this.mainCharacterType(), this.mainCharacter.bind(this));
if(temp === null) { return null; }
if(typeof temp === 'string') { return temp; }
return temp.unpack()
})();
_o.charactersType = this.bb!.createScalarList(this.charactersType.bind(this), this.charactersTypeLength());
_o.characters = (() => {
let ret = [];
for(let targetEnumIndex = 0; targetEnumIndex < this.charactersTypeLength(); ++targetEnumIndex) {
let targetEnum = this.charactersType(targetEnumIndex);
if(targetEnum === null || Character[targetEnum!] === 'NONE') { continue; }
let temp = unionListToCharacter(targetEnum, this.characters.bind(this), targetEnumIndex);
if(temp === null) { continue; }
if(typeof temp === 'string') { ret.push(temp); continue; }
ret.push(temp.unpack());
}
return ret;
})();
}
}
export class MovieT {
constructor(
public mainCharacterType: Character = Character.NONE,
public mainCharacter: AttackerT|BookReaderT|RapunzelT|string|null = null,
public charactersType: (Character)[] = [],
public characters: (AttackerT|BookReaderT|RapunzelT|string)[] = []
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
const mainCharacter = builder.createObjectOffset(this.mainCharacter);
const charactersType = Movie.createCharactersTypeVector(builder, this.charactersType);
const characters = Movie.createCharactersVector(builder, builder.createObjectOffsetList(this.characters));
return Movie.createMovie(builder,
this.mainCharacterType,
mainCharacter,
charactersType,
characters
);
}
}

77
tests/ts/my-game/example/ability.ts Normal file
View File

@@ -0,0 +1,77 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class Ability {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Ability {
this.bb_pos = i;
this.bb = bb;
return this;
}
id():number {
return this.bb!.readUint32(this.bb_pos);
}
mutate_id(value:number):boolean {
this.bb!.writeUint32(this.bb_pos + 0, value);
return true;
}
distance():number {
return this.bb!.readUint32(this.bb_pos + 4);
}
mutate_distance(value:number):boolean {
this.bb!.writeUint32(this.bb_pos + 4, value);
return true;
}
static getFullyQualifiedName():string {
return 'MyGame.Example.Ability';
}
static sizeOf():number {
return 8;
}
static createAbility(builder:flatbuffers.Builder, id: number, distance: number):flatbuffers.Offset {
builder.prep(4, 8);
builder.writeInt32(distance);
builder.writeInt32(id);
return builder.offset();
}
unpack(): AbilityT {
return new AbilityT(
this.id(),
this.distance()
);
}
unpackTo(_o: AbilityT): void {
_o.id = this.id();
_o.distance = this.distance();
}
}
export class AbilityT {
constructor(
public id: number = 0,
public distance: number = 0
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return Ability.createAbility(builder,
this.id,
this.distance
);
}
}

39
tests/ts/my-game/example/any-ambiguous-aliases.ts Normal file
View File

@@ -0,0 +1,39 @@
// automatically generated by the FlatBuffers compiler, do not modify
import { Monster, MonsterT } from '../../my-game/example/monster';
export enum AnyAmbiguousAliases{
NONE = 0,
M1 = 1,
M2 = 2,
M3 = 3
}
export function unionToAnyAmbiguousAliases(
type: AnyAmbiguousAliases,
accessor: (obj:Monster) => Monster|null
): Monster|null {
switch(AnyAmbiguousAliases[type]) {
case 'NONE': return null;
case 'M1': return accessor(new Monster())! as Monster;
case 'M2': return accessor(new Monster())! as Monster;
case 'M3': return accessor(new Monster())! as Monster;
default: return null;
}
}
export function unionListToAnyAmbiguousAliases(
type: AnyAmbiguousAliases,
accessor: (index: number, obj:Monster) => Monster|null,
index: number
): Monster|null {
switch(AnyAmbiguousAliases[type]) {
case 'NONE': return null;
case 'M1': return accessor(index, new Monster())! as Monster;
case 'M2': return accessor(index, new Monster())! as Monster;
case 'M3': return accessor(index, new Monster())! as Monster;
default: return null;
}
}

41
tests/ts/my-game/example/any-unique-aliases.ts Normal file
View File

@@ -0,0 +1,41 @@
// automatically generated by the FlatBuffers compiler, do not modify
import { Monster as MyGameExample2Monster, MonsterT as MyGameExample2MonsterT } from '../../my-game/example2/monster';
import { Monster, MonsterT } from '../../my-game/example/monster';
import { TestSimpleTableWithEnum, TestSimpleTableWithEnumT } from '../../my-game/example/test-simple-table-with-enum';
export enum AnyUniqueAliases{
NONE = 0,
M = 1,
TS = 2,
M2 = 3
}
export function unionToAnyUniqueAliases(
type: AnyUniqueAliases,
accessor: (obj:Monster|MyGameExample2Monster|TestSimpleTableWithEnum) => Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null
): Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null {
switch(AnyUniqueAliases[type]) {
case 'NONE': return null;
case 'M': return accessor(new Monster())! as Monster;
case 'TS': return accessor(new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
case 'M2': return accessor(new MyGameExample2Monster())! as MyGameExample2Monster;
default: return null;
}
}
export function unionListToAnyUniqueAliases(
type: AnyUniqueAliases,
accessor: (index: number, obj:Monster|MyGameExample2Monster|TestSimpleTableWithEnum) => Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null,
index: number
): Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null {
switch(AnyUniqueAliases[type]) {
case 'NONE': return null;
case 'M': return accessor(index, new Monster())! as Monster;
case 'TS': return accessor(index, new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
case 'M2': return accessor(index, new MyGameExample2Monster())! as MyGameExample2Monster;
default: return null;
}
}

41
tests/ts/my-game/example/any.ts Normal file
View File

@@ -0,0 +1,41 @@
// automatically generated by the FlatBuffers compiler, do not modify
import { Monster as MyGameExample2Monster, MonsterT as MyGameExample2MonsterT } from '../../my-game/example2/monster';
import { Monster, MonsterT } from '../../my-game/example/monster';
import { TestSimpleTableWithEnum, TestSimpleTableWithEnumT } from '../../my-game/example/test-simple-table-with-enum';
export enum Any{
NONE = 0,
Monster = 1,
TestSimpleTableWithEnum = 2,
MyGame_Example2_Monster = 3
}
export function unionToAny(
type: Any,
accessor: (obj:Monster|MyGameExample2Monster|TestSimpleTableWithEnum) => Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null
): Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null {
switch(Any[type]) {
case 'NONE': return null;
case 'Monster': return accessor(new Monster())! as Monster;
case 'TestSimpleTableWithEnum': return accessor(new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
case 'MyGame_Example2_Monster': return accessor(new MyGameExample2Monster())! as MyGameExample2Monster;
default: return null;
}
}
export function unionListToAny(
type: Any,
accessor: (index: number, obj:Monster|MyGameExample2Monster|TestSimpleTableWithEnum) => Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null,
index: number
): Monster|MyGameExample2Monster|TestSimpleTableWithEnum|null {
switch(Any[type]) {
case 'NONE': return null;
case 'Monster': return accessor(index, new Monster())! as Monster;
case 'TestSimpleTableWithEnum': return accessor(index, new TestSimpleTableWithEnum())! as TestSimpleTableWithEnum;
case 'MyGame_Example2_Monster': return accessor(index, new MyGameExample2Monster())! as MyGameExample2Monster;
default: return null;
}
}

20
tests/ts/my-game/example/color.ts Normal file
View File

@@ -0,0 +1,20 @@
// automatically generated by the FlatBuffers compiler, do not modify
/**
* Composite components of Monster color.
*/
export enum Color{
Red = 1,
/**
* \brief color Green
* Green is bit_flag with value (1u << 1)
*/
Green = 2,
/**
* \brief color Blue (1u << 3)
*/
Blue = 8
}

1370
tests/ts/my-game/example/monster.ts Normal file
View File

File diff suppressed because it is too large Load Diff

9
tests/ts/my-game/example/race.ts Normal file
View File

@@ -0,0 +1,9 @@
// automatically generated by the FlatBuffers compiler, do not modify
export enum Race{
None = -1,
Human = 0,
Dwarf = 1,
Elf = 2
}

95
tests/ts/my-game/example/referrable.ts Normal file
View File

@@ -0,0 +1,95 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class Referrable {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Referrable {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsReferrable(bb:flatbuffers.ByteBuffer, obj?:Referrable):Referrable {
return (obj || new Referrable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsReferrable(bb:flatbuffers.ByteBuffer, obj?:Referrable):Referrable {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Referrable()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
id():flatbuffers.Long {
const offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(0, 0);
}
mutate_id(value:flatbuffers.Long):boolean {
const offset = this.bb!.__offset(this.bb_pos, 4);
if (offset === 0) {
return false;
}
this.bb!.writeUint64(this.bb_pos + offset, value);
return true;
}
static getFullyQualifiedName():string {
return 'MyGame.Example.Referrable';
}
static startReferrable(builder:flatbuffers.Builder) {
builder.startObject(1);
}
static addId(builder:flatbuffers.Builder, id:flatbuffers.Long) {
builder.addFieldInt64(0, id, builder.createLong(0, 0));
}
static endReferrable(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static createReferrable(builder:flatbuffers.Builder, id:flatbuffers.Long):flatbuffers.Offset {
Referrable.startReferrable(builder);
Referrable.addId(builder, id);
return Referrable.endReferrable(builder);
}
serialize():Uint8Array {
return this.bb!.bytes();
}
static deserialize(buffer: Uint8Array):Referrable {
return Referrable.getRootAsReferrable(new flatbuffers.ByteBuffer(buffer))
}
unpack(): ReferrableT {
return new ReferrableT(
this.id()
);
}
unpackTo(_o: ReferrableT): void {
_o.id = this.id();
}
}
export class ReferrableT {
constructor(
public id: flatbuffers.Long = flatbuffers.createLong(0, 0)
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return Referrable.createReferrable(builder,
this.id
);
}
}

138
tests/ts/my-game/example/stat.ts Normal file
View File

@@ -0,0 +1,138 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class Stat {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Stat {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsStat(bb:flatbuffers.ByteBuffer, obj?:Stat):Stat {
return (obj || new Stat()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsStat(bb:flatbuffers.ByteBuffer, obj?:Stat):Stat {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Stat()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
id():string|null
id(optionalEncoding:flatbuffers.Encoding):string|Uint8Array|null
id(optionalEncoding?:any):string|Uint8Array|null {
const offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.__string(this.bb_pos + offset, optionalEncoding) : null;
}
val():flatbuffers.Long {
const offset = this.bb!.__offset(this.bb_pos, 6);
return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);
}
mutate_val(value:flatbuffers.Long):boolean {
const offset = this.bb!.__offset(this.bb_pos, 6);
if (offset === 0) {
return false;
}
this.bb!.writeInt64(this.bb_pos + offset, value);
return true;
}
count():number {
const offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0;
}
mutate_count(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 8);
if (offset === 0) {
return false;
}
this.bb!.writeUint16(this.bb_pos + offset, value);
return true;
}
static getFullyQualifiedName():string {
return 'MyGame.Example.Stat';
}
static startStat(builder:flatbuffers.Builder) {
builder.startObject(3);
}
static addId(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset) {
builder.addFieldOffset(0, idOffset, 0);
}
static addVal(builder:flatbuffers.Builder, val:flatbuffers.Long) {
builder.addFieldInt64(1, val, builder.createLong(0, 0));
}
static addCount(builder:flatbuffers.Builder, count:number) {
builder.addFieldInt16(2, count, 0);
}
static endStat(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static createStat(builder:flatbuffers.Builder, idOffset:flatbuffers.Offset, val:flatbuffers.Long, count:number):flatbuffers.Offset {
Stat.startStat(builder);
Stat.addId(builder, idOffset);
Stat.addVal(builder, val);
Stat.addCount(builder, count);
return Stat.endStat(builder);
}
serialize():Uint8Array {
return this.bb!.bytes();
}
static deserialize(buffer: Uint8Array):Stat {
return Stat.getRootAsStat(new flatbuffers.ByteBuffer(buffer))
}
unpack(): StatT {
return new StatT(
this.id(),
this.val(),
this.count()
);
}
unpackTo(_o: StatT): void {
_o.id = this.id();
_o.val = this.val();
_o.count = this.count();
}
}
export class StatT {
constructor(
public id: string|Uint8Array|null = null,
public val: flatbuffers.Long = flatbuffers.createLong(0, 0),
public count: number = 0
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
const id = (this.id !== null ? builder.createString(this.id!) : 0);
return Stat.createStat(builder,
id,
this.val,
this.count
);
}
}

96
tests/ts/my-game/example/test-simple-table-with-enum.ts Normal file
View File

@@ -0,0 +1,96 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
import { Color } from '../../my-game/example/color';
export class TestSimpleTableWithEnum {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):TestSimpleTableWithEnum {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsTestSimpleTableWithEnum(bb:flatbuffers.ByteBuffer, obj?:TestSimpleTableWithEnum):TestSimpleTableWithEnum {
return (obj || new TestSimpleTableWithEnum()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsTestSimpleTableWithEnum(bb:flatbuffers.ByteBuffer, obj?:TestSimpleTableWithEnum):TestSimpleTableWithEnum {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new TestSimpleTableWithEnum()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
color():Color {
const offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.readUint8(this.bb_pos + offset) : Color.Green;
}
mutate_color(value:Color):boolean {
const offset = this.bb!.__offset(this.bb_pos, 4);
if (offset === 0) {
return false;
}
this.bb!.writeUint8(this.bb_pos + offset, value);
return true;
}
static getFullyQualifiedName():string {
return 'MyGame.Example.TestSimpleTableWithEnum';
}
static startTestSimpleTableWithEnum(builder:flatbuffers.Builder) {
builder.startObject(1);
}
static addColor(builder:flatbuffers.Builder, color:Color) {
builder.addFieldInt8(0, color, Color.Green);
}
static endTestSimpleTableWithEnum(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static createTestSimpleTableWithEnum(builder:flatbuffers.Builder, color:Color):flatbuffers.Offset {
TestSimpleTableWithEnum.startTestSimpleTableWithEnum(builder);
TestSimpleTableWithEnum.addColor(builder, color);
return TestSimpleTableWithEnum.endTestSimpleTableWithEnum(builder);
}
serialize():Uint8Array {
return this.bb!.bytes();
}
static deserialize(buffer: Uint8Array):TestSimpleTableWithEnum {
return TestSimpleTableWithEnum.getRootAsTestSimpleTableWithEnum(new flatbuffers.ByteBuffer(buffer))
}
unpack(): TestSimpleTableWithEnumT {
return new TestSimpleTableWithEnumT(
this.color()
);
}
unpackTo(_o: TestSimpleTableWithEnumT): void {
_o.color = this.color();
}
}
export class TestSimpleTableWithEnumT {
constructor(
public color: Color = Color.Green
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return TestSimpleTableWithEnum.createTestSimpleTableWithEnum(builder,
this.color
);
}
}

78
tests/ts/my-game/example/test.ts Normal file
View File

@@ -0,0 +1,78 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class Test {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Test {
this.bb_pos = i;
this.bb = bb;
return this;
}
a():number {
return this.bb!.readInt16(this.bb_pos);
}
mutate_a(value:number):boolean {
this.bb!.writeInt16(this.bb_pos + 0, value);
return true;
}
b():number {
return this.bb!.readInt8(this.bb_pos + 2);
}
mutate_b(value:number):boolean {
this.bb!.writeInt8(this.bb_pos + 2, value);
return true;
}
static getFullyQualifiedName():string {
return 'MyGame.Example.Test';
}
static sizeOf():number {
return 4;
}
static createTest(builder:flatbuffers.Builder, a: number, b: number):flatbuffers.Offset {
builder.prep(2, 4);
builder.pad(1);
builder.writeInt8(b);
builder.writeInt16(a);
return builder.offset();
}
unpack(): TestT {
return new TestT(
this.a(),
this.b()
);
}
unpackTo(_o: TestT): void {
_o.a = this.a();
_o.b = this.b();
}
}
export class TestT {
constructor(
public a: number = 0,
public b: number = 0
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return Test.createTest(builder,
this.a,
this.b
);
}
}

405
tests/ts/my-game/example/type-aliases.ts Normal file
View File

@@ -0,0 +1,405 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class TypeAliases {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):TypeAliases {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsTypeAliases(bb:flatbuffers.ByteBuffer, obj?:TypeAliases):TypeAliases {
return (obj || new TypeAliases()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsTypeAliases(bb:flatbuffers.ByteBuffer, obj?:TypeAliases):TypeAliases {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new TypeAliases()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
i8():number {
const offset = this.bb!.__offset(this.bb_pos, 4);
return offset ? this.bb!.readInt8(this.bb_pos + offset) : 0;
}
mutate_i8(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 4);
if (offset === 0) {
return false;
}
this.bb!.writeInt8(this.bb_pos + offset, value);
return true;
}
u8():number {
const offset = this.bb!.__offset(this.bb_pos, 6);
return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0;
}
mutate_u8(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 6);
if (offset === 0) {
return false;
}
this.bb!.writeUint8(this.bb_pos + offset, value);
return true;
}
i16():number {
const offset = this.bb!.__offset(this.bb_pos, 8);
return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0;
}
mutate_i16(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 8);
if (offset === 0) {
return false;
}
this.bb!.writeInt16(this.bb_pos + offset, value);
return true;
}
u16():number {
const offset = this.bb!.__offset(this.bb_pos, 10);
return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0;
}
mutate_u16(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 10);
if (offset === 0) {
return false;
}
this.bb!.writeUint16(this.bb_pos + offset, value);
return true;
}
i32():number {
const offset = this.bb!.__offset(this.bb_pos, 12);
return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0;
}
mutate_i32(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 12);
if (offset === 0) {
return false;
}
this.bb!.writeInt32(this.bb_pos + offset, value);
return true;
}
u32():number {
const offset = this.bb!.__offset(this.bb_pos, 14);
return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0;
}
mutate_u32(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 14);
if (offset === 0) {
return false;
}
this.bb!.writeUint32(this.bb_pos + offset, value);
return true;
}
i64():flatbuffers.Long {
const offset = this.bb!.__offset(this.bb_pos, 16);
return offset ? this.bb!.readInt64(this.bb_pos + offset) : this.bb!.createLong(0, 0);
}
mutate_i64(value:flatbuffers.Long):boolean {
const offset = this.bb!.__offset(this.bb_pos, 16);
if (offset === 0) {
return false;
}
this.bb!.writeInt64(this.bb_pos + offset, value);
return true;
}
u64():flatbuffers.Long {
const offset = this.bb!.__offset(this.bb_pos, 18);
return offset ? this.bb!.readUint64(this.bb_pos + offset) : this.bb!.createLong(0, 0);
}
mutate_u64(value:flatbuffers.Long):boolean {
const offset = this.bb!.__offset(this.bb_pos, 18);
if (offset === 0) {
return false;
}
this.bb!.writeUint64(this.bb_pos + offset, value);
return true;
}
f32():number {
const offset = this.bb!.__offset(this.bb_pos, 20);
return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0;
}
mutate_f32(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 20);
if (offset === 0) {
return false;
}
this.bb!.writeFloat32(this.bb_pos + offset, value);
return true;
}
f64():number {
const offset = this.bb!.__offset(this.bb_pos, 22);
return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0;
}
mutate_f64(value:number):boolean {
const offset = this.bb!.__offset(this.bb_pos, 22);
if (offset === 0) {
return false;
}
this.bb!.writeFloat64(this.bb_pos + offset, value);
return true;
}
v8(index: number):number|null {
const offset = this.bb!.__offset(this.bb_pos, 24);
return offset ? this.bb!.readInt8(this.bb!.__vector(this.bb_pos + offset) + index) : 0;
}
v8Length():number {
const offset = this.bb!.__offset(this.bb_pos, 24);
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
}
v8Array():Int8Array|null {
const offset = this.bb!.__offset(this.bb_pos, 24);
return offset ? new Int8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
}
vf64(index: number):number|null {
const offset = this.bb!.__offset(this.bb_pos, 26);
return offset ? this.bb!.readFloat64(this.bb!.__vector(this.bb_pos + offset) + index * 8) : 0;
}
vf64Length():number {
const offset = this.bb!.__offset(this.bb_pos, 26);
return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0;
}
vf64Array():Float64Array|null {
const offset = this.bb!.__offset(this.bb_pos, 26);
return offset ? new Float64Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null;
}
static getFullyQualifiedName():string {
return 'MyGame.Example.TypeAliases';
}
static startTypeAliases(builder:flatbuffers.Builder) {
builder.startObject(12);
}
static addI8(builder:flatbuffers.Builder, i8:number) {
builder.addFieldInt8(0, i8, 0);
}
static addU8(builder:flatbuffers.Builder, u8:number) {
builder.addFieldInt8(1, u8, 0);
}
static addI16(builder:flatbuffers.Builder, i16:number) {
builder.addFieldInt16(2, i16, 0);
}
static addU16(builder:flatbuffers.Builder, u16:number) {
builder.addFieldInt16(3, u16, 0);
}
static addI32(builder:flatbuffers.Builder, i32:number) {
builder.addFieldInt32(4, i32, 0);
}
static addU32(builder:flatbuffers.Builder, u32:number) {
builder.addFieldInt32(5, u32, 0);
}
static addI64(builder:flatbuffers.Builder, i64:flatbuffers.Long) {
builder.addFieldInt64(6, i64, builder.createLong(0, 0));
}
static addU64(builder:flatbuffers.Builder, u64:flatbuffers.Long) {
builder.addFieldInt64(7, u64, builder.createLong(0, 0));
}
static addF32(builder:flatbuffers.Builder, f32:number) {
builder.addFieldFloat32(8, f32, 0.0);
}
static addF64(builder:flatbuffers.Builder, f64:number) {
builder.addFieldFloat64(9, f64, 0.0);
}
static addV8(builder:flatbuffers.Builder, v8Offset:flatbuffers.Offset) {
builder.addFieldOffset(10, v8Offset, 0);
}
static createV8Vector(builder:flatbuffers.Builder, data:number[]|Int8Array):flatbuffers.Offset;
/**
* @deprecated This Uint8Array overload will be removed in the future.
*/
static createV8Vector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
static createV8Vector(builder:flatbuffers.Builder, data:number[]|Int8Array|Uint8Array):flatbuffers.Offset {
builder.startVector(1, data.length, 1);
for (let i = data.length - 1; i >= 0; i--) {
builder.addInt8(data[i]);
}
return builder.endVector();
}
static startV8Vector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(1, numElems, 1);
}
static addVf64(builder:flatbuffers.Builder, vf64Offset:flatbuffers.Offset) {
builder.addFieldOffset(11, vf64Offset, 0);
}
static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Float64Array):flatbuffers.Offset;
/**
* @deprecated This Uint8Array overload will be removed in the future.
*/
static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset;
static createVf64Vector(builder:flatbuffers.Builder, data:number[]|Float64Array|Uint8Array):flatbuffers.Offset {
builder.startVector(8, data.length, 8);
for (let i = data.length - 1; i >= 0; i--) {
builder.addFloat64(data[i]);
}
return builder.endVector();
}
static startVf64Vector(builder:flatbuffers.Builder, numElems:number) {
builder.startVector(8, numElems, 8);
}
static endTypeAliases(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static createTypeAliases(builder:flatbuffers.Builder, i8:number, u8:number, i16:number, u16:number, i32:number, u32:number, i64:flatbuffers.Long, u64:flatbuffers.Long, f32:number, f64:number, v8Offset:flatbuffers.Offset, vf64Offset:flatbuffers.Offset):flatbuffers.Offset {
TypeAliases.startTypeAliases(builder);
TypeAliases.addI8(builder, i8);
TypeAliases.addU8(builder, u8);
TypeAliases.addI16(builder, i16);
TypeAliases.addU16(builder, u16);
TypeAliases.addI32(builder, i32);
TypeAliases.addU32(builder, u32);
TypeAliases.addI64(builder, i64);
TypeAliases.addU64(builder, u64);
TypeAliases.addF32(builder, f32);
TypeAliases.addF64(builder, f64);
TypeAliases.addV8(builder, v8Offset);
TypeAliases.addVf64(builder, vf64Offset);
return TypeAliases.endTypeAliases(builder);
}
serialize():Uint8Array {
return this.bb!.bytes();
}
static deserialize(buffer: Uint8Array):TypeAliases {
return TypeAliases.getRootAsTypeAliases(new flatbuffers.ByteBuffer(buffer))
}
unpack(): TypeAliasesT {
return new TypeAliasesT(
this.i8(),
this.u8(),
this.i16(),
this.u16(),
this.i32(),
this.u32(),
this.i64(),
this.u64(),
this.f32(),
this.f64(),
this.bb!.createScalarList(this.v8.bind(this), this.v8Length()),
this.bb!.createScalarList(this.vf64.bind(this), this.vf64Length())
);
}
unpackTo(_o: TypeAliasesT): void {
_o.i8 = this.i8();
_o.u8 = this.u8();
_o.i16 = this.i16();
_o.u16 = this.u16();
_o.i32 = this.i32();
_o.u32 = this.u32();
_o.i64 = this.i64();
_o.u64 = this.u64();
_o.f32 = this.f32();
_o.f64 = this.f64();
_o.v8 = this.bb!.createScalarList(this.v8.bind(this), this.v8Length());
_o.vf64 = this.bb!.createScalarList(this.vf64.bind(this), this.vf64Length());
}
}
export class TypeAliasesT {
constructor(
public i8: number = 0,
public u8: number = 0,
public i16: number = 0,
public u16: number = 0,
public i32: number = 0,
public u32: number = 0,
public i64: flatbuffers.Long = flatbuffers.createLong(0, 0),
public u64: flatbuffers.Long = flatbuffers.createLong(0, 0),
public f32: number = 0.0,
public f64: number = 0.0,
public v8: (number)[] = [],
public vf64: (number)[] = []
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
const v8 = TypeAliases.createV8Vector(builder, this.v8);
const vf64 = TypeAliases.createVf64Vector(builder, this.vf64);
return TypeAliases.createTypeAliases(builder,
this.i8,
this.u8,
this.i16,
this.u16,
this.i32,
this.u32,
this.i64,
this.u64,
this.f32,
this.f64,
v8,
vf64
);
}
}

137
tests/ts/my-game/example/vec3.ts Normal file
View File

@@ -0,0 +1,137 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
import { Color } from '../../my-game/example/color';
import { Test, TestT } from '../../my-game/example/test';
export class Vec3 {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Vec3 {
this.bb_pos = i;
this.bb = bb;
return this;
}
x():number {
return this.bb!.readFloat32(this.bb_pos);
}
mutate_x(value:number):boolean {
this.bb!.writeFloat32(this.bb_pos + 0, value);
return true;
}
y():number {
return this.bb!.readFloat32(this.bb_pos + 4);
}
mutate_y(value:number):boolean {
this.bb!.writeFloat32(this.bb_pos + 4, value);
return true;
}
z():number {
return this.bb!.readFloat32(this.bb_pos + 8);
}
mutate_z(value:number):boolean {
this.bb!.writeFloat32(this.bb_pos + 8, value);
return true;
}
test1():number {
return this.bb!.readFloat64(this.bb_pos + 16);
}
mutate_test1(value:number):boolean {
this.bb!.writeFloat64(this.bb_pos + 16, value);
return true;
}
test2():Color {
return this.bb!.readUint8(this.bb_pos + 24);
}
mutate_test2(value:Color):boolean {
this.bb!.writeUint8(this.bb_pos + 24, value);
return true;
}
test3(obj?:Test):Test|null {
return (obj || new Test()).__init(this.bb_pos + 26, this.bb!);
}
static getFullyQualifiedName():string {
return 'MyGame.Example.Vec3';
}
static sizeOf():number {
return 32;
}
static createVec3(builder:flatbuffers.Builder, x: number, y: number, z: number, test1: number, test2: Color, test3_a: number, test3_b: number):flatbuffers.Offset {
builder.prep(8, 32);
builder.pad(2);
builder.prep(2, 4);
builder.pad(1);
builder.writeInt8(test3_b);
builder.writeInt16(test3_a);
builder.pad(1);
builder.writeInt8(test2);
builder.writeFloat64(test1);
builder.pad(4);
builder.writeFloat32(z);
builder.writeFloat32(y);
builder.writeFloat32(x);
return builder.offset();
}
unpack(): Vec3T {
return new Vec3T(
this.x(),
this.y(),
this.z(),
this.test1(),
this.test2(),
(this.test3() !== null ? this.test3()!.unpack() : null)
);
}
unpackTo(_o: Vec3T): void {
_o.x = this.x();
_o.y = this.y();
_o.z = this.z();
_o.test1 = this.test1();
_o.test2 = this.test2();
_o.test3 = (this.test3() !== null ? this.test3()!.unpack() : null);
}
}
export class Vec3T {
constructor(
public x: number = 0.0,
public y: number = 0.0,
public z: number = 0.0,
public test1: number = 0.0,
public test2: Color = 0,
public test3: TestT|null = null
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return Vec3.createVec3(builder,
this.x,
this.y,
this.z,
this.test1,
this.test2,
(this.test3 === null ? 0 : this.test3.a!),
(this.test3 === null ? 0 : this.test3.b!)
);
}
}

66
tests/ts/my-game/example2/monster.ts Normal file
View File

@@ -0,0 +1,66 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class Monster {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Monster {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsMonster(bb:flatbuffers.ByteBuffer, obj?:Monster):Monster {
return (obj || new Monster()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsMonster(bb:flatbuffers.ByteBuffer, obj?:Monster):Monster {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new Monster()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getFullyQualifiedName():string {
return 'MyGame.Example2.Monster';
}
static startMonster(builder:flatbuffers.Builder) {
builder.startObject(0);
}
static endMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static createMonster(builder:flatbuffers.Builder):flatbuffers.Offset {
Monster.startMonster(builder);
return Monster.endMonster(builder);
}
serialize():Uint8Array {
return this.bb!.bytes();
}
static deserialize(buffer: Uint8Array):Monster {
return Monster.getRootAsMonster(new flatbuffers.ByteBuffer(buffer))
}
unpack(): MonsterT {
return new MonsterT();
}
unpackTo(_o: MonsterT): void {}
}
export class MonsterT {
constructor(){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return Monster.createMonster(builder);
}
}

66
tests/ts/my-game/in-parent-namespace.ts Normal file
View File

@@ -0,0 +1,66 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class InParentNamespace {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):InParentNamespace {
this.bb_pos = i;
this.bb = bb;
return this;
}
static getRootAsInParentNamespace(bb:flatbuffers.ByteBuffer, obj?:InParentNamespace):InParentNamespace {
return (obj || new InParentNamespace()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getSizePrefixedRootAsInParentNamespace(bb:flatbuffers.ByteBuffer, obj?:InParentNamespace):InParentNamespace {
bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
return (obj || new InParentNamespace()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
}
static getFullyQualifiedName():string {
return 'MyGame.InParentNamespace';
}
static startInParentNamespace(builder:flatbuffers.Builder) {
builder.startObject(0);
}
static endInParentNamespace(builder:flatbuffers.Builder):flatbuffers.Offset {
const offset = builder.endObject();
return offset;
}
static createInParentNamespace(builder:flatbuffers.Builder):flatbuffers.Offset {
InParentNamespace.startInParentNamespace(builder);
return InParentNamespace.endInParentNamespace(builder);
}
serialize():Uint8Array {
return this.bb!.bytes();
}
static deserialize(buffer: Uint8Array):InParentNamespace {
return InParentNamespace.getRootAsInParentNamespace(new flatbuffers.ByteBuffer(buffer))
}
unpack(): InParentNamespaceT {
return new InParentNamespaceT();
}
unpackTo(_o: InParentNamespaceT): void {}
}
export class InParentNamespaceT {
constructor(){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return InParentNamespace.createInParentNamespace(builder);
}
}

58
tests/ts/rapunzel.ts Normal file
View File

@@ -0,0 +1,58 @@
// automatically generated by the FlatBuffers compiler, do not modify
import * as flatbuffers from 'flatbuffers';
export class Rapunzel {
bb: flatbuffers.ByteBuffer|null = null;
bb_pos = 0;
__init(i:number, bb:flatbuffers.ByteBuffer):Rapunzel {
this.bb_pos = i;
this.bb = bb;
return this;
}
hairLength():number {
return this.bb!.readInt32(this.bb_pos);
}
static getFullyQualifiedName():string {
return 'Rapunzel';
}
static sizeOf():number {
return 4;
}
static createRapunzel(builder:flatbuffers.Builder, hair_length: number):flatbuffers.Offset {
builder.prep(4, 4);
builder.writeInt32(hair_length);
return builder.offset();
}
unpack(): RapunzelT {
return new RapunzelT(
this.hairLength()
);
}
unpackTo(_o: RapunzelT): void {
_o.hairLength = this.hairLength();
}
}
export class RapunzelT {
constructor(
public hairLength: number = 0
){}
pack(builder:flatbuffers.Builder): flatbuffers.Offset {
return Rapunzel.createRapunzel(builder,
this.hairLength
);
}
}

18
tests/tsconfig.json Normal file
View File

@@ -0,0 +1,18 @@
{
"compilerOptions": {
"target": "ES6",
"lib": ["ES2015", "ES2020.BigInt", "DOM"],
"moduleResolution": "Node",
"noImplicitAny": true,
"strict": true,
"noUnusedParameters": false,
"noUnusedLocals": false,
"noImplicitReturns": true,
"strictNullChecks": true,
"baseUrl": ".",
"noEmit": false,
"outDir": "./ts"
},
"include": [ "ts/**/*.ts" ],
"exclude": []
}