From c2668fc0e27c9cbcb5c3376442c94170f3d5ab2d Mon Sep 17 00:00:00 2001 From: Chris <6701545+ink-su@users.noreply.github.com> Date: Sat, 7 Jan 2023 13:42:28 -0800 Subject: [PATCH] Add ts-no-import-ext flag (#7748) Co-authored-by: Derek Bailey --- include/flatbuffers/idl.h | 2 + src/flatc.cpp | 2 + src/idl_gen_ts.cpp | 10 +- tests/ts/TypeScriptTest.py | 6 + .../optional-scalars/optional-byte.js | 7 + .../optional-scalars/optional-byte.ts | 7 + .../optional-scalars/scalar-stuff.js | 344 ++++++++++++++ .../optional-scalars/scalar-stuff.ts | 427 ++++++++++++++++++ tests/ts/no_import_ext/optional_scalars.js | 1 + tests/ts/no_import_ext/optional_scalars.ts | 1 + .../optional_scalars_generated.js | 3 + .../optional_scalars_generated.ts | 4 + tests/ts/tsconfig.json | 3 +- 13 files changed, 812 insertions(+), 5 deletions(-) create mode 100644 tests/ts/no_import_ext/optional-scalars/optional-byte.js create mode 100644 tests/ts/no_import_ext/optional-scalars/optional-byte.ts create mode 100644 tests/ts/no_import_ext/optional-scalars/scalar-stuff.js create mode 100644 tests/ts/no_import_ext/optional-scalars/scalar-stuff.ts create mode 100644 tests/ts/no_import_ext/optional_scalars.js create mode 100644 tests/ts/no_import_ext/optional_scalars.ts create mode 100644 tests/ts/no_import_ext/optional_scalars_generated.js create mode 100644 tests/ts/no_import_ext/optional_scalars_generated.ts diff --git a/include/flatbuffers/idl.h b/include/flatbuffers/idl.h index c4460b3db..9e5bb25eb 100644 --- a/include/flatbuffers/idl.h +++ b/include/flatbuffers/idl.h @@ -659,6 +659,7 @@ struct IDLOptions { bool json_nested_flexbuffers; bool json_nested_legacy_flatbuffers; bool ts_flat_file; + bool ts_no_import_ext; bool no_leak_private_annotations; bool require_json_eof; @@ -763,6 +764,7 @@ struct IDLOptions { json_nested_flexbuffers(true), json_nested_legacy_flatbuffers(false), ts_flat_file(false), + ts_no_import_ext(false), no_leak_private_annotations(false), require_json_eof(true), mini_reflect(IDLOptions::kNone), diff --git a/src/flatc.cpp b/src/flatc.cpp index 02119dd63..3d6856e95 100644 --- a/src/flatc.cpp +++ b/src/flatc.cpp @@ -613,6 +613,8 @@ int FlatCompiler::Compile(int argc, const char **argv) { opts.json_nested_legacy_flatbuffers = true; } else if (arg == "--ts-flat-files") { opts.ts_flat_file = true; + } else if (arg == "--ts-no-import-ext") { + opts.ts_no_import_ext = true; } else if (arg == "--no-leak-private-annotation") { opts.no_leak_private_annotations = true; } else if (arg == "--annotate") { diff --git a/src/idl_gen_ts.cpp b/src/idl_gen_ts.cpp index ca95e4a38..aac409c97 100644 --- a/src/idl_gen_ts.cpp +++ b/src/idl_gen_ts.cpp @@ -256,15 +256,16 @@ class TsGenerator : public BaseGenerator { // specified here? Should we always be adding the "./" for a relative // path or turn it off if --include-prefix is specified, or something // else? + std::string import_extension = parser_.opts.ts_no_import_ext ? "" : ".js"; std::string include_name = - "./" + flatbuffers::StripExtension(include_file); + "./" + flatbuffers::StripExtension(include_file) + import_extension; code += "import {"; for (const auto &pair : it.second) { code += namer_.EscapeKeyword(pair.first) + " as " + namer_.EscapeKeyword(pair.second) + ", "; } code.resize(code.size() - 2); - code += "} from '" + include_name + ".js';\n"; + code += "} from '" + include_name + "';\n"; } code += "\n"; } @@ -883,10 +884,11 @@ class TsGenerator : public BaseGenerator { import.object_name = object_name; import.bare_file_path = bare_file_path; import.rel_file_path = rel_file_path; + std::string import_extension = parser_.opts.ts_no_import_ext ? "" : ".js"; import.import_statement = "import { " + symbols_expression + " } from '" + - rel_file_path + ".js';"; + rel_file_path + import_extension + "';"; import.export_statement = "export { " + symbols_expression + " } from '." + - bare_file_path + ".js';"; + bare_file_path + import_extension + "';"; import.dependency = &dependency; import.dependent = &dependent; diff --git a/tests/ts/TypeScriptTest.py b/tests/ts/TypeScriptTest.py index bb8dfcad4..4fe7ab653 100755 --- a/tests/ts/TypeScriptTest.py +++ b/tests/ts/TypeScriptTest.py @@ -84,6 +84,12 @@ flatc( schema="../optional_scalars.fbs", ) +flatc( + options=["--ts", "--reflect-names", "--gen-name-strings", "--ts-no-import-ext"], + schema="../optional_scalars.fbs", + prefix="no_import_ext", +) + flatc( options=["--ts", "--reflect-names", "--gen-name-strings", "--gen-mutable", "--gen-object-api"], schema=[ diff --git a/tests/ts/no_import_ext/optional-scalars/optional-byte.js b/tests/ts/no_import_ext/optional-scalars/optional-byte.js new file mode 100644 index 000000000..8257f93a4 --- /dev/null +++ b/tests/ts/no_import_ext/optional-scalars/optional-byte.js @@ -0,0 +1,7 @@ +// automatically generated by the FlatBuffers compiler, do not modify +export var OptionalByte; +(function (OptionalByte) { + OptionalByte[OptionalByte["None"] = 0] = "None"; + OptionalByte[OptionalByte["One"] = 1] = "One"; + OptionalByte[OptionalByte["Two"] = 2] = "Two"; +})(OptionalByte || (OptionalByte = {})); diff --git a/tests/ts/no_import_ext/optional-scalars/optional-byte.ts b/tests/ts/no_import_ext/optional-scalars/optional-byte.ts new file mode 100644 index 000000000..f4db265e2 --- /dev/null +++ b/tests/ts/no_import_ext/optional-scalars/optional-byte.ts @@ -0,0 +1,7 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export enum OptionalByte { + None = 0, + One = 1, + Two = 2 +} diff --git a/tests/ts/no_import_ext/optional-scalars/scalar-stuff.js b/tests/ts/no_import_ext/optional-scalars/scalar-stuff.js new file mode 100644 index 000000000..41d4bb0e6 --- /dev/null +++ b/tests/ts/no_import_ext/optional-scalars/scalar-stuff.js @@ -0,0 +1,344 @@ +// automatically generated by the FlatBuffers compiler, do not modify +import * as flatbuffers from 'flatbuffers'; +import { OptionalByte } from '../optional-scalars/optional-byte'; +export class ScalarStuff { + constructor() { + this.bb = null; + this.bb_pos = 0; + } + __init(i, bb) { + this.bb_pos = i; + this.bb = bb; + return this; + } + static getRootAsScalarStuff(bb, obj) { + return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + } + static getSizePrefixedRootAsScalarStuff(bb, obj) { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + } + static bufferHasIdentifier(bb) { + return bb.__has_identifier('NULL'); + } + justI8() { + const offset = this.bb.__offset(this.bb_pos, 4); + return offset ? this.bb.readInt8(this.bb_pos + offset) : 0; + } + maybeI8() { + const offset = this.bb.__offset(this.bb_pos, 6); + return offset ? this.bb.readInt8(this.bb_pos + offset) : null; + } + defaultI8() { + const offset = this.bb.__offset(this.bb_pos, 8); + return offset ? this.bb.readInt8(this.bb_pos + offset) : 42; + } + justU8() { + const offset = this.bb.__offset(this.bb_pos, 10); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 0; + } + maybeU8() { + const offset = this.bb.__offset(this.bb_pos, 12); + return offset ? this.bb.readUint8(this.bb_pos + offset) : null; + } + defaultU8() { + const offset = this.bb.__offset(this.bb_pos, 14); + return offset ? this.bb.readUint8(this.bb_pos + offset) : 42; + } + justI16() { + const offset = this.bb.__offset(this.bb_pos, 16); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 0; + } + maybeI16() { + const offset = this.bb.__offset(this.bb_pos, 18); + return offset ? this.bb.readInt16(this.bb_pos + offset) : null; + } + defaultI16() { + const offset = this.bb.__offset(this.bb_pos, 20); + return offset ? this.bb.readInt16(this.bb_pos + offset) : 42; + } + justU16() { + const offset = this.bb.__offset(this.bb_pos, 22); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 0; + } + maybeU16() { + const offset = this.bb.__offset(this.bb_pos, 24); + return offset ? this.bb.readUint16(this.bb_pos + offset) : null; + } + defaultU16() { + const offset = this.bb.__offset(this.bb_pos, 26); + return offset ? this.bb.readUint16(this.bb_pos + offset) : 42; + } + justI32() { + const offset = this.bb.__offset(this.bb_pos, 28); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 0; + } + maybeI32() { + const offset = this.bb.__offset(this.bb_pos, 30); + return offset ? this.bb.readInt32(this.bb_pos + offset) : null; + } + defaultI32() { + const offset = this.bb.__offset(this.bb_pos, 32); + return offset ? this.bb.readInt32(this.bb_pos + offset) : 42; + } + justU32() { + const offset = this.bb.__offset(this.bb_pos, 34); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 0; + } + maybeU32() { + const offset = this.bb.__offset(this.bb_pos, 36); + return offset ? this.bb.readUint32(this.bb_pos + offset) : null; + } + defaultU32() { + const offset = this.bb.__offset(this.bb_pos, 38); + return offset ? this.bb.readUint32(this.bb_pos + offset) : 42; + } + justI64() { + const offset = this.bb.__offset(this.bb_pos, 40); + return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt('0'); + } + maybeI64() { + const offset = this.bb.__offset(this.bb_pos, 42); + return offset ? this.bb.readInt64(this.bb_pos + offset) : null; + } + defaultI64() { + const offset = this.bb.__offset(this.bb_pos, 44); + return offset ? this.bb.readInt64(this.bb_pos + offset) : BigInt('42'); + } + justU64() { + const offset = this.bb.__offset(this.bb_pos, 46); + return offset ? this.bb.readUint64(this.bb_pos + offset) : BigInt('0'); + } + maybeU64() { + const offset = this.bb.__offset(this.bb_pos, 48); + return offset ? this.bb.readUint64(this.bb_pos + offset) : null; + } + defaultU64() { + const offset = this.bb.__offset(this.bb_pos, 50); + return offset ? this.bb.readUint64(this.bb_pos + offset) : BigInt('42'); + } + justF32() { + const offset = this.bb.__offset(this.bb_pos, 52); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 0.0; + } + maybeF32() { + const offset = this.bb.__offset(this.bb_pos, 54); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : null; + } + defaultF32() { + const offset = this.bb.__offset(this.bb_pos, 56); + return offset ? this.bb.readFloat32(this.bb_pos + offset) : 42.0; + } + justF64() { + const offset = this.bb.__offset(this.bb_pos, 58); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 0.0; + } + maybeF64() { + const offset = this.bb.__offset(this.bb_pos, 60); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : null; + } + defaultF64() { + const offset = this.bb.__offset(this.bb_pos, 62); + return offset ? this.bb.readFloat64(this.bb_pos + offset) : 42.0; + } + justBool() { + const offset = this.bb.__offset(this.bb_pos, 64); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : false; + } + maybeBool() { + const offset = this.bb.__offset(this.bb_pos, 66); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : null; + } + defaultBool() { + const offset = this.bb.__offset(this.bb_pos, 68); + return offset ? !!this.bb.readInt8(this.bb_pos + offset) : true; + } + justEnum() { + const offset = this.bb.__offset(this.bb_pos, 70); + return offset ? this.bb.readInt8(this.bb_pos + offset) : OptionalByte.None; + } + maybeEnum() { + const offset = this.bb.__offset(this.bb_pos, 72); + return offset ? this.bb.readInt8(this.bb_pos + offset) : null; + } + defaultEnum() { + const offset = this.bb.__offset(this.bb_pos, 74); + return offset ? this.bb.readInt8(this.bb_pos + offset) : OptionalByte.One; + } + static getFullyQualifiedName() { + return 'optional_scalars.ScalarStuff'; + } + static startScalarStuff(builder) { + builder.startObject(36); + } + static addJustI8(builder, justI8) { + builder.addFieldInt8(0, justI8, 0); + } + static addMaybeI8(builder, maybeI8) { + builder.addFieldInt8(1, maybeI8, 0); + } + static addDefaultI8(builder, defaultI8) { + builder.addFieldInt8(2, defaultI8, 42); + } + static addJustU8(builder, justU8) { + builder.addFieldInt8(3, justU8, 0); + } + static addMaybeU8(builder, maybeU8) { + builder.addFieldInt8(4, maybeU8, 0); + } + static addDefaultU8(builder, defaultU8) { + builder.addFieldInt8(5, defaultU8, 42); + } + static addJustI16(builder, justI16) { + builder.addFieldInt16(6, justI16, 0); + } + static addMaybeI16(builder, maybeI16) { + builder.addFieldInt16(7, maybeI16, 0); + } + static addDefaultI16(builder, defaultI16) { + builder.addFieldInt16(8, defaultI16, 42); + } + static addJustU16(builder, justU16) { + builder.addFieldInt16(9, justU16, 0); + } + static addMaybeU16(builder, maybeU16) { + builder.addFieldInt16(10, maybeU16, 0); + } + static addDefaultU16(builder, defaultU16) { + builder.addFieldInt16(11, defaultU16, 42); + } + static addJustI32(builder, justI32) { + builder.addFieldInt32(12, justI32, 0); + } + static addMaybeI32(builder, maybeI32) { + builder.addFieldInt32(13, maybeI32, 0); + } + static addDefaultI32(builder, defaultI32) { + builder.addFieldInt32(14, defaultI32, 42); + } + static addJustU32(builder, justU32) { + builder.addFieldInt32(15, justU32, 0); + } + static addMaybeU32(builder, maybeU32) { + builder.addFieldInt32(16, maybeU32, 0); + } + static addDefaultU32(builder, defaultU32) { + builder.addFieldInt32(17, defaultU32, 42); + } + static addJustI64(builder, justI64) { + builder.addFieldInt64(18, justI64, BigInt('0')); + } + static addMaybeI64(builder, maybeI64) { + builder.addFieldInt64(19, maybeI64, BigInt(0)); + } + static addDefaultI64(builder, defaultI64) { + builder.addFieldInt64(20, defaultI64, BigInt('42')); + } + static addJustU64(builder, justU64) { + builder.addFieldInt64(21, justU64, BigInt('0')); + } + static addMaybeU64(builder, maybeU64) { + builder.addFieldInt64(22, maybeU64, BigInt(0)); + } + static addDefaultU64(builder, defaultU64) { + builder.addFieldInt64(23, defaultU64, BigInt('42')); + } + static addJustF32(builder, justF32) { + builder.addFieldFloat32(24, justF32, 0.0); + } + static addMaybeF32(builder, maybeF32) { + builder.addFieldFloat32(25, maybeF32, 0); + } + static addDefaultF32(builder, defaultF32) { + builder.addFieldFloat32(26, defaultF32, 42.0); + } + static addJustF64(builder, justF64) { + builder.addFieldFloat64(27, justF64, 0.0); + } + static addMaybeF64(builder, maybeF64) { + builder.addFieldFloat64(28, maybeF64, 0); + } + static addDefaultF64(builder, defaultF64) { + builder.addFieldFloat64(29, defaultF64, 42.0); + } + static addJustBool(builder, justBool) { + builder.addFieldInt8(30, +justBool, +false); + } + static addMaybeBool(builder, maybeBool) { + builder.addFieldInt8(31, +maybeBool, 0); + } + static addDefaultBool(builder, defaultBool) { + builder.addFieldInt8(32, +defaultBool, +true); + } + static addJustEnum(builder, justEnum) { + builder.addFieldInt8(33, justEnum, OptionalByte.None); + } + static addMaybeEnum(builder, maybeEnum) { + builder.addFieldInt8(34, maybeEnum, 0); + } + static addDefaultEnum(builder, defaultEnum) { + builder.addFieldInt8(35, defaultEnum, OptionalByte.One); + } + static endScalarStuff(builder) { + const offset = builder.endObject(); + return offset; + } + static finishScalarStuffBuffer(builder, offset) { + builder.finish(offset, 'NULL'); + } + static finishSizePrefixedScalarStuffBuffer(builder, offset) { + builder.finish(offset, 'NULL', true); + } + static createScalarStuff(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) { + 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); + } +} diff --git a/tests/ts/no_import_ext/optional-scalars/scalar-stuff.ts b/tests/ts/no_import_ext/optional-scalars/scalar-stuff.ts new file mode 100644 index 000000000..d6256c384 --- /dev/null +++ b/tests/ts/no_import_ext/optional-scalars/scalar-stuff.ts @@ -0,0 +1,427 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +import * as flatbuffers from 'flatbuffers'; + +import { OptionalByte } from '../optional-scalars/optional-byte'; + + +export class ScalarStuff { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ScalarStuff { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsScalarStuff(bb:flatbuffers.ByteBuffer, obj?:ScalarStuff):ScalarStuff { + return (obj || new ScalarStuff()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +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); +} + +static bufferHasIdentifier(bb:flatbuffers.ByteBuffer):boolean { + return bb.__has_identifier('NULL'); +} + +justI8():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : 0; +} + +maybeI8():number|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : null; +} + +defaultI8():number { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : 42; +} + +justU8():number { + const offset = this.bb!.__offset(this.bb_pos, 10); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : 0; +} + +maybeU8():number|null { + const offset = this.bb!.__offset(this.bb_pos, 12); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : null; +} + +defaultU8():number { + const offset = this.bb!.__offset(this.bb_pos, 14); + return offset ? this.bb!.readUint8(this.bb_pos + offset) : 42; +} + +justI16():number { + const offset = this.bb!.__offset(this.bb_pos, 16); + return offset ? this.bb!.readInt16(this.bb_pos + offset) : 0; +} + +maybeI16():number|null { + const offset = this.bb!.__offset(this.bb_pos, 18); + return offset ? this.bb!.readInt16(this.bb_pos + offset) : null; +} + +defaultI16():number { + const offset = this.bb!.__offset(this.bb_pos, 20); + return offset ? this.bb!.readInt16(this.bb_pos + offset) : 42; +} + +justU16():number { + const offset = this.bb!.__offset(this.bb_pos, 22); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 0; +} + +maybeU16():number|null { + const offset = this.bb!.__offset(this.bb_pos, 24); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : null; +} + +defaultU16():number { + const offset = this.bb!.__offset(this.bb_pos, 26); + return offset ? this.bb!.readUint16(this.bb_pos + offset) : 42; +} + +justI32():number { + const offset = this.bb!.__offset(this.bb_pos, 28); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 0; +} + +maybeI32():number|null { + const offset = this.bb!.__offset(this.bb_pos, 30); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : null; +} + +defaultI32():number { + const offset = this.bb!.__offset(this.bb_pos, 32); + return offset ? this.bb!.readInt32(this.bb_pos + offset) : 42; +} + +justU32():number { + const offset = this.bb!.__offset(this.bb_pos, 34); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +maybeU32():number|null { + const offset = this.bb!.__offset(this.bb_pos, 36); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : null; +} + +defaultU32():number { + const offset = this.bb!.__offset(this.bb_pos, 38); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 42; +} + +justI64():bigint { + const offset = this.bb!.__offset(this.bb_pos, 40); + return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0'); +} + +maybeI64():bigint|null { + const offset = this.bb!.__offset(this.bb_pos, 42); + return offset ? this.bb!.readInt64(this.bb_pos + offset) : null; +} + +defaultI64():bigint { + const offset = this.bb!.__offset(this.bb_pos, 44); + return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('42'); +} + +justU64():bigint { + const offset = this.bb!.__offset(this.bb_pos, 46); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('0'); +} + +maybeU64():bigint|null { + const offset = this.bb!.__offset(this.bb_pos, 48); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : null; +} + +defaultU64():bigint { + const offset = this.bb!.__offset(this.bb_pos, 50); + return offset ? this.bb!.readUint64(this.bb_pos + offset) : BigInt('42'); +} + +justF32():number { + const offset = this.bb!.__offset(this.bb_pos, 52); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 0.0; +} + +maybeF32():number|null { + const offset = this.bb!.__offset(this.bb_pos, 54); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : null; +} + +defaultF32():number { + const offset = this.bb!.__offset(this.bb_pos, 56); + return offset ? this.bb!.readFloat32(this.bb_pos + offset) : 42.0; +} + +justF64():number { + const offset = this.bb!.__offset(this.bb_pos, 58); + return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 0.0; +} + +maybeF64():number|null { + const offset = this.bb!.__offset(this.bb_pos, 60); + return offset ? this.bb!.readFloat64(this.bb_pos + offset) : null; +} + +defaultF64():number { + const offset = this.bb!.__offset(this.bb_pos, 62); + return offset ? this.bb!.readFloat64(this.bb_pos + offset) : 42.0; +} + +justBool():boolean { + const offset = this.bb!.__offset(this.bb_pos, 64); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +maybeBool():boolean|null { + const offset = this.bb!.__offset(this.bb_pos, 66); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : null; +} + +defaultBool():boolean { + const offset = this.bb!.__offset(this.bb_pos, 68); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : true; +} + +justEnum():OptionalByte { + const offset = this.bb!.__offset(this.bb_pos, 70); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : OptionalByte.None; +} + +maybeEnum():OptionalByte|null { + const offset = this.bb!.__offset(this.bb_pos, 72); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : null; +} + +defaultEnum():OptionalByte { + const offset = this.bb!.__offset(this.bb_pos, 74); + return offset ? this.bb!.readInt8(this.bb_pos + offset) : OptionalByte.One; +} + +static getFullyQualifiedName():string { + return 'optional_scalars.ScalarStuff'; +} + +static startScalarStuff(builder:flatbuffers.Builder) { + builder.startObject(36); +} + +static addJustI8(builder:flatbuffers.Builder, justI8:number) { + builder.addFieldInt8(0, justI8, 0); +} + +static addMaybeI8(builder:flatbuffers.Builder, maybeI8:number) { + builder.addFieldInt8(1, maybeI8, 0); +} + +static addDefaultI8(builder:flatbuffers.Builder, defaultI8:number) { + builder.addFieldInt8(2, defaultI8, 42); +} + +static addJustU8(builder:flatbuffers.Builder, justU8:number) { + builder.addFieldInt8(3, justU8, 0); +} + +static addMaybeU8(builder:flatbuffers.Builder, maybeU8:number) { + builder.addFieldInt8(4, maybeU8, 0); +} + +static addDefaultU8(builder:flatbuffers.Builder, defaultU8:number) { + builder.addFieldInt8(5, defaultU8, 42); +} + +static addJustI16(builder:flatbuffers.Builder, justI16:number) { + builder.addFieldInt16(6, justI16, 0); +} + +static addMaybeI16(builder:flatbuffers.Builder, maybeI16:number) { + builder.addFieldInt16(7, maybeI16, 0); +} + +static addDefaultI16(builder:flatbuffers.Builder, defaultI16:number) { + builder.addFieldInt16(8, defaultI16, 42); +} + +static addJustU16(builder:flatbuffers.Builder, justU16:number) { + builder.addFieldInt16(9, justU16, 0); +} + +static addMaybeU16(builder:flatbuffers.Builder, maybeU16:number) { + builder.addFieldInt16(10, maybeU16, 0); +} + +static addDefaultU16(builder:flatbuffers.Builder, defaultU16:number) { + builder.addFieldInt16(11, defaultU16, 42); +} + +static addJustI32(builder:flatbuffers.Builder, justI32:number) { + builder.addFieldInt32(12, justI32, 0); +} + +static addMaybeI32(builder:flatbuffers.Builder, maybeI32:number) { + builder.addFieldInt32(13, maybeI32, 0); +} + +static addDefaultI32(builder:flatbuffers.Builder, defaultI32:number) { + builder.addFieldInt32(14, defaultI32, 42); +} + +static addJustU32(builder:flatbuffers.Builder, justU32:number) { + builder.addFieldInt32(15, justU32, 0); +} + +static addMaybeU32(builder:flatbuffers.Builder, maybeU32:number) { + builder.addFieldInt32(16, maybeU32, 0); +} + +static addDefaultU32(builder:flatbuffers.Builder, defaultU32:number) { + builder.addFieldInt32(17, defaultU32, 42); +} + +static addJustI64(builder:flatbuffers.Builder, justI64:bigint) { + builder.addFieldInt64(18, justI64, BigInt('0')); +} + +static addMaybeI64(builder:flatbuffers.Builder, maybeI64:bigint) { + builder.addFieldInt64(19, maybeI64, BigInt(0)); +} + +static addDefaultI64(builder:flatbuffers.Builder, defaultI64:bigint) { + builder.addFieldInt64(20, defaultI64, BigInt('42')); +} + +static addJustU64(builder:flatbuffers.Builder, justU64:bigint) { + builder.addFieldInt64(21, justU64, BigInt('0')); +} + +static addMaybeU64(builder:flatbuffers.Builder, maybeU64:bigint) { + builder.addFieldInt64(22, maybeU64, BigInt(0)); +} + +static addDefaultU64(builder:flatbuffers.Builder, defaultU64:bigint) { + builder.addFieldInt64(23, defaultU64, BigInt('42')); +} + +static addJustF32(builder:flatbuffers.Builder, justF32:number) { + builder.addFieldFloat32(24, justF32, 0.0); +} + +static addMaybeF32(builder:flatbuffers.Builder, maybeF32:number) { + builder.addFieldFloat32(25, maybeF32, 0); +} + +static addDefaultF32(builder:flatbuffers.Builder, defaultF32:number) { + builder.addFieldFloat32(26, defaultF32, 42.0); +} + +static addJustF64(builder:flatbuffers.Builder, justF64:number) { + builder.addFieldFloat64(27, justF64, 0.0); +} + +static addMaybeF64(builder:flatbuffers.Builder, maybeF64:number) { + builder.addFieldFloat64(28, maybeF64, 0); +} + +static addDefaultF64(builder:flatbuffers.Builder, defaultF64:number) { + builder.addFieldFloat64(29, defaultF64, 42.0); +} + +static addJustBool(builder:flatbuffers.Builder, justBool:boolean) { + builder.addFieldInt8(30, +justBool, +false); +} + +static addMaybeBool(builder:flatbuffers.Builder, maybeBool:boolean) { + builder.addFieldInt8(31, +maybeBool, 0); +} + +static addDefaultBool(builder:flatbuffers.Builder, defaultBool:boolean) { + builder.addFieldInt8(32, +defaultBool, +true); +} + +static addJustEnum(builder:flatbuffers.Builder, justEnum:OptionalByte) { + builder.addFieldInt8(33, justEnum, OptionalByte.None); +} + +static addMaybeEnum(builder:flatbuffers.Builder, maybeEnum:OptionalByte) { + builder.addFieldInt8(34, maybeEnum, 0); +} + +static addDefaultEnum(builder:flatbuffers.Builder, defaultEnum:OptionalByte) { + builder.addFieldInt8(35, defaultEnum, OptionalByte.One); +} + +static endScalarStuff(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static finishScalarStuffBuffer(builder:flatbuffers.Builder, offset:flatbuffers.Offset) { + builder.finish(offset, 'NULL'); +} + +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:bigint, maybeI64:bigint|null, defaultI64:bigint, justU64:bigint, maybeU64:bigint|null, defaultU64:bigint, justF32:number, maybeF32:number|null, defaultF32:number, justF64:number, maybeF64:number|null, defaultF64:number, justBool:boolean, maybeBool:boolean|null, defaultBool:boolean, justEnum:OptionalByte, maybeEnum:OptionalByte|null, defaultEnum: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); +} +} diff --git a/tests/ts/no_import_ext/optional_scalars.js b/tests/ts/no_import_ext/optional_scalars.js new file mode 100644 index 000000000..6d9830c02 --- /dev/null +++ b/tests/ts/no_import_ext/optional_scalars.js @@ -0,0 +1 @@ +export { OptionalByte } from './optional-scalars/optional-byte'; diff --git a/tests/ts/no_import_ext/optional_scalars.ts b/tests/ts/no_import_ext/optional_scalars.ts new file mode 100644 index 000000000..6d9830c02 --- /dev/null +++ b/tests/ts/no_import_ext/optional_scalars.ts @@ -0,0 +1 @@ +export { OptionalByte } from './optional-scalars/optional-byte'; diff --git a/tests/ts/no_import_ext/optional_scalars_generated.js b/tests/ts/no_import_ext/optional_scalars_generated.js new file mode 100644 index 000000000..09e2631cf --- /dev/null +++ b/tests/ts/no_import_ext/optional_scalars_generated.js @@ -0,0 +1,3 @@ +// automatically generated by the FlatBuffers compiler, do not modify +export { OptionalByte } from './optional-scalars/optional-byte'; +export { ScalarStuff } from './optional-scalars/scalar-stuff'; diff --git a/tests/ts/no_import_ext/optional_scalars_generated.ts b/tests/ts/no_import_ext/optional_scalars_generated.ts new file mode 100644 index 000000000..4a83c439f --- /dev/null +++ b/tests/ts/no_import_ext/optional_scalars_generated.ts @@ -0,0 +1,4 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +export { OptionalByte } from './optional-scalars/optional-byte'; +export { ScalarStuff } from './optional-scalars/scalar-stuff'; diff --git a/tests/ts/tsconfig.json b/tests/ts/tsconfig.json index 4678c63e6..aa5f55bc6 100644 --- a/tests/ts/tsconfig.json +++ b/tests/ts/tsconfig.json @@ -21,6 +21,7 @@ "optional_scalars/**/*.ts", "namespace_test/**/*.ts", "union_vector/**/*.ts", - "arrays_test_complex/**/*.ts" + "arrays_test_complex/**/*.ts", + "no_import_ext/**/*.ts" ] }