true}.name].hi} />"
- )
- ).toBe(
- `export var hi = jsx("div", {
- hi: foo[{ name: () => true }.name].hi
-}, undefined, false, undefined, this);
-`
- );
- expect(
- bun.transformSync("export var hi =
")
- ).toBe(
- `export var hi = jsx(Foo, {
- NODE_ENV: "development"
-}, undefined, false, undefined, this);
-`
- );
-
- expect(
- bun.transformSync("export var hi =
")
- ).toBe(
- `export var hi = jsx("div", {
- baz: foo["baz"].bar?.baz
-}, undefined, false, undefined, this);
-`
- );
- try {
- bun.transformSync("export var hi =
");
- throw new Error("Expected error");
- } catch (e) {
- expect(e.errors[0].message.includes('Expected ">"')).toBe(true);
- }
-
- expect(
- bun.transformSync("export var hi =
")
- ).toBe(
- `export var hi = jsx("div", {
- Foo,
- children: jsx(Foo, {}, undefined, false, undefined, this)
-}, undefined, false, undefined, this);
-`
- );
- expect(
- bun.transformSync("export var hi =
")
- ).toBe(
- `export var hi = jsx("div", {
- Foo,
- children: jsx(Foo, {}, undefined, false, undefined, this)
-}, undefined, false, undefined, this);
-`
- );
-
- expect(bun.transformSync("export var hi =
{123}}
").trim()).toBe(
- `export var hi = jsx("div", {
- children: [
- 123,
- "}"
- ]
-}, undefined, true, undefined, this);
- `.trim()
- );
- });
-
- describe("inline JSX", () => {
- const inliner = new Bun.Transpiler({
- loader: "tsx",
- define: {
- "process.env.NODE_ENV": JSON.stringify("production"),
- user_undefined: "undefined",
- },
- platform: "bun",
- jsxOptimizationInline: true,
- treeShaking: false,
- });
-
- it("inlines static JSX into object literals", () => {
- expect(
- inliner
- .transformSync(
- `
-export var hi =
{123}
-export var hiWithKey =
{123}
-export var hiWithRef =
{123}
-
-export var ComponentThatChecksDefaultProps =
-export var ComponentThatChecksDefaultPropsAndHasChildren =
my child
-export var ComponentThatHasSpreadCausesDeopt =
-
-`.trim()
- )
- .trim()
- ).toBe(
- `var $$typeof = Symbol.for("react.element");
-export var hi = {
- $$typeof,
- type: "div",
- key: null,
- ref: null,
- props: {
- children: 123
- },
- _owner: null
-};
-export var hiWithKey = {
- $$typeof,
- type: "div",
- key: "hey",
- ref: null,
- props: {
- children: 123
- },
- _owner: null
-};
-export var hiWithRef = jsx("div", {
- ref: foo,
- children: 123
-});
-export var ComponentThatChecksDefaultProps = {
- $$typeof,
- type: Hello,
- key: null,
- ref: null,
- props: Hello.defaultProps || {},
- _owner: null
-};
-export var ComponentThatChecksDefaultPropsAndHasChildren = {
- $$typeof,
- type: Hello,
- key: null,
- ref: null,
- props: __merge({
- children: "my child"
- }, Hello.defaultProps),
- _owner: null
-};
-export var ComponentThatHasSpreadCausesDeopt = jsx(Hello, {
- ...spread
-});
-`.trim()
- );
- });
- });
-
- it("require with a dynamic non-string expression", () => {
- var nodeTranspiler = new Bun.Transpiler({ platform: "node" });
- expect(nodeTranspiler.transformSync("require('hi' + bar)")).toBe(
- 'require("hi" + bar);\n'
- );
- });
-
- it("CommonJS", () => {
- var nodeTranspiler = new Bun.Transpiler({ platform: "node" });
- expect(nodeTranspiler.transformSync("module.require('hi' + 123)")).toBe(
- 'require("hi" + 123);\n'
- );
-
- expect(
- nodeTranspiler.transformSync("module.require(1 ? 'foo' : 'bar')")
- ).toBe('require("foo");\n');
- expect(nodeTranspiler.transformSync("require(1 ? 'foo' : 'bar')")).toBe(
- 'require("foo");\n'
- );
-
- expect(
- nodeTranspiler.transformSync("module.require(unknown ? 'foo' : 'bar')")
- ).toBe('unknown ? require("foo") : require("bar");\n');
- });
-
- describe("regressions", () => {
- it("unexpected super", () => {
- const input = `
- 'use strict';
-
- const ErrorReportingMixinBase = require('./mixin-base');
- const PositionTrackingPreprocessorMixin = require('../position-tracking/preprocessor-mixin');
- const Mixin = require('../../utils/mixin');
-
- class ErrorReportingPreprocessorMixin extends ErrorReportingMixinBase {
- constructor(preprocessor, opts) {
- super(preprocessor, opts);
-
- this.posTracker = Mixin.install(preprocessor, PositionTrackingPreprocessorMixin);
- this.lastErrOffset = -1;
- }
-
- _reportError(code) {
- //NOTE: avoid reporting error twice on advance/retreat
- if (this.lastErrOffset !== this.posTracker.offset) {
- this.lastErrOffset = this.posTracker.offset;
- super._reportError(code);
- }
- }
- }
-
- module.exports = ErrorReportingPreprocessorMixin;
-
-
-`;
- expect(transpiler.transformSync(input, "js").length > 0).toBe(true);
- });
- });
-
- describe("scanImports", () => {
- it("reports import paths, excluding types", () => {
- const imports = transpiler.scanImports(code, "tsx");
- expect(imports.filter(({ path }) => path === "remix")).toHaveLength(1);
- expect(imports.filter(({ path }) => path === "mod")).toHaveLength(0);
- expect(imports.filter(({ path }) => path === "react")).toHaveLength(1);
- expect(imports).toHaveLength(2);
- });
- });
-
- const parsed = (
- code,
- trim = true,
- autoExport = false,
- transpiler_ = transpiler
- ) => {
- if (autoExport) {
- code = "export default (" + code + ")";
- }
-
- var out = transpiler_.transformSync(code, "js");
- if (autoExport && out.startsWith("export default ")) {
- out = out.substring("export default ".length);
- }
-
- if (trim) {
- out = out.trim();
-
- if (out.endsWith(";")) {
- out = out.substring(0, out.length - 1);
- }
-
- return out.trim();
- }
-
- return out;
- };
-
- const expectPrinted = (code, out) => {
- expect(parsed(code, true, true)).toBe(out);
- };
-
- const expectPrinted_ = (code, out) => {
- expect(parsed(code, !out.endsWith(";\n"), false)).toBe(out);
- };
-
- const expectBunPrinted_ = (code, out) => {
- expect(parsed(code, !out.endsWith(";\n"), false, bunTranspiler)).toBe(out);
- };
-
- const expectParseError = (code, message) => {
- try {
- parsed(code, false, false);
- } catch (er) {
- var err = er;
- if (er instanceof AggregateError) {
- err = err.errors[0];
- }
-
- expect(er.message).toBe(message);
-
- return;
- }
-
- throw new Error("Expected parse error for code\n\t" + code);
- };
- const ts = {
- parsed: (code, trim = true, autoExport = false) => {
- if (autoExport) {
- code = "export default (" + code + ")";
- }
-
- var out = transpiler.transformSync(code, "ts");
- if (autoExport && out.startsWith("export default ")) {
- out = out.substring("export default ".length);
- }
-
- if (trim) {
- out = out.trim();
-
- if (out.endsWith(";")) {
- out = out.substring(0, out.length - 1);
- }
-
- return out.trim();
- }
-
- return out;
- },
-
- expectPrinted: (code, out) => {
- expect(ts.parsed(code, true, true)).toBe(out);
- },
-
- expectPrinted_: (code, out) => {
- expect(ts.parsed(code, !out.endsWith(";\n"), false)).toBe(out);
- },
-
- expectParseError: (code, message) => {
- try {
- ts.parsed(code, false, false);
- } catch (er) {
- var err = er;
- if (er instanceof AggregateError) {
- err = err.errors[0];
- }
-
- expect(er.message).toBe(message);
-
- return;
- }
-
- throw new Error("Expected parse error for code\n\t" + code);
- },
- };
-
- describe("parser", () => {
- it("arrays", () => {
- expectPrinted("[]", "[]");
- expectPrinted("[,]", "[,]");
- expectPrinted("[1]", "[1]");
- expectPrinted("[1,]", "[1]");
- expectPrinted("[,1]", "[, 1]");
- expectPrinted("[1,2]", "[1, 2]");
- expectPrinted("[,1,2]", "[, 1, 2]");
- expectPrinted("[1,,2]", "[1, , 2]");
- expectPrinted("[1,2,]", "[1, 2]");
- expectPrinted("[1,2,,]", "[1, 2, ,]");
- });
-
- it("exponentiation", () => {
- expectPrinted("(delete x) ** 0", "(delete x) ** 0");
- expectPrinted("(delete x.prop) ** 0", "(delete x.prop) ** 0");
- expectPrinted("(delete x[0]) ** 0", "(delete x[0]) ** 0");
-
- expectPrinted("(delete x?.prop) ** 0", "(delete x?.prop) ** 0");
-
- expectPrinted("(void x) ** 0", "(void x) ** 0");
- expectPrinted("(typeof x) ** 0", "(typeof x) ** 0");
- expectPrinted("(+x) ** 0", "(+x) ** 0");
- expectPrinted("(-x) ** 0", "(-x) ** 0");
- expectPrinted("(~x) ** 0", "(~x) ** 0");
- expectPrinted("(!x) ** 0", "(!x) ** 0");
- expectPrinted("(await x) ** 0", "(await x) ** 0");
- expectPrinted("(await -x) ** 0", "(await -x) ** 0");
-
- expectPrinted("--x ** 2", "--x ** 2");
- expectPrinted("++x ** 2", "++x ** 2");
- expectPrinted("x-- ** 2", "x-- ** 2");
- expectPrinted("x++ ** 2", "x++ ** 2");
-
- expectPrinted("(-x) ** 2", "(-x) ** 2");
- expectPrinted("(+x) ** 2", "(+x) ** 2");
- expectPrinted("(~x) ** 2", "(~x) ** 2");
- expectPrinted("(!x) ** 2", "(!x) ** 2");
- expectPrinted("(-1) ** 2", "(-1) ** 2");
- expectPrinted("(+1) ** 2", "1 ** 2");
- expectPrinted("(~1) ** 2", "(~1) ** 2");
- expectPrinted("(!1) ** 2", "false ** 2");
- expectPrinted("(void x) ** 2", "(void x) ** 2");
- expectPrinted("(delete x) ** 2", "(delete x) ** 2");
- expectPrinted("(typeof x) ** 2", "(typeof x) ** 2");
- expectPrinted("undefined ** 2", "undefined ** 2");
-
- expectParseError("-x ** 2", "Unexpected **");
- expectParseError("+x ** 2", "Unexpected **");
- expectParseError("~x ** 2", "Unexpected **");
- expectParseError("!x ** 2", "Unexpected **");
- expectParseError("void x ** 2", "Unexpected **");
- expectParseError("delete x ** 2", "Unexpected **");
- expectParseError("typeof x ** 2", "Unexpected **");
-
- expectParseError("-x.y() ** 2", "Unexpected **");
- expectParseError("+x.y() ** 2", "Unexpected **");
- expectParseError("~x.y() ** 2", "Unexpected **");
- expectParseError("!x.y() ** 2", "Unexpected **");
- expectParseError("void x.y() ** 2", "Unexpected **");
- expectParseError("delete x.y() ** 2", "Unexpected **");
- expectParseError("typeof x.y() ** 2", "Unexpected **");
-
- expectParseError("delete x ** 0", "Unexpected **");
- expectParseError("delete x.prop ** 0", "Unexpected **");
- expectParseError("delete x[0] ** 0", "Unexpected **");
- expectParseError("delete x?.prop ** 0", "Unexpected **");
- expectParseError("void x ** 0", "Unexpected **");
- expectParseError("typeof x ** 0", "Unexpected **");
- expectParseError("+x ** 0", "Unexpected **");
- expectParseError("-x ** 0", "Unexpected **");
- expectParseError("~x ** 0", "Unexpected **");
- expectParseError("!x ** 0", "Unexpected **");
- expectParseError("await x ** 0", "Unexpected **");
- expectParseError("await -x ** 0", "Unexpected **");
- });
-
- it("await", () => {
- expectPrinted("await x", "await x");
- expectPrinted("await +x", "await +x");
- expectPrinted("await -x", "await -x");
- expectPrinted("await ~x", "await ~x");
- expectPrinted("await !x", "await !x");
- expectPrinted("await --x", "await --x");
- expectPrinted("await ++x", "await ++x");
- expectPrinted("await x--", "await x--");
- expectPrinted("await x++", "await x++");
- expectPrinted("await void x", "await void x");
- expectPrinted("await typeof x", "await typeof x");
- expectPrinted("await (x * y)", "await (x * y)");
- expectPrinted("await (x ** y)", "await (x ** y)");
-
- expectPrinted_(
- "async function f() { await delete x }",
- "async function f() {\n await delete x;\n}"
- );
-
- // expectParseError(
- // "await delete x",
- // "Delete of a bare identifier cannot be used in an ECMAScript module"
- // );
- });
-
- it("import assert", () => {
- expectPrinted_(
- `import json from "./foo.json" assert { type: "json" };`,
- `import json from "./foo.json"`
- );
- expectPrinted_(
- `import json from "./foo.json";`,
- `import json from "./foo.json"`
- );
- expectPrinted_(
- `import("./foo.json", { type: "json" });`,
- `import("./foo.json")`
- );
- });
-
- it("import with unicode escape", () => {
- expectPrinted_(
- `import { name } from 'mod\\u1011';`,
- `import {name} from "mod\\u1011"`
- );
- });
-
- it("fold string addition", () => {
- expectPrinted_(
- `export const foo = "a" + "b";`,
- `export const foo = "ab"`
- );
- expectPrinted_(
- `export const foo = "F" + "0" + "F" + "0123456789" + "ABCDEF" + "0123456789ABCDEFF0123456789ABCDEF00" + "b";`,
- `export const foo = "F0F0123456789ABCDEF0123456789ABCDEFF0123456789ABCDEF00b"`
- );
- expectPrinted_(
- `export const foo = "a" + 1 + "b";`,
- `export const foo = "a" + 1 + "b"`
- );
- expectPrinted_(
- `export const foo = "a" + "b" + 1 + "b";`,
- `export const foo = "ab" + 1 + "b"`
- );
- expectPrinted_(
- `export const foo = "a" + "b" + 1 + "b" + "c";`,
- `export const foo = "ab" + 1 + "bc"`
- );
- });
-
- it("numeric constants", () => {
- expectBunPrinted_("export const foo = 1 + 2", "export const foo = 3");
- expectBunPrinted_("export const foo = 1 - 2", "export const foo = -1");
- expectBunPrinted_("export const foo = 1 * 2", "export const foo = 2");
- });
-
- it("pass objects to macros", () => {
- var object = {
- helloooooooo: {
- message: [12345],
- },
- };
-
- const output = bunTranspiler.transformSync(
- `
- import {whatDidIPass} from 'inline';
-
- export function foo() {
- return whatDidIPass();
- }
- `,
- object
- );
- expect(output).toBe(`export function foo() {
- return {
- helloooooooo: {
- message: [
- 12345
- ]
- }
- };
-}
-`);
- });
-
- it("rewrite string to length", () => {
- expectPrinted_(
- `export const foo = "a".length + "b".length;`,
- `export const foo = 1 + 1`
- );
- expectBunPrinted_(
- `export const foo = "a".length + "b".length;`,
- `export const foo = 2`
- );
- });
-
- describe("Bun.js", () => {
- it("require -> import.meta.require", () => {
- expectBunPrinted_(
- `export const foo = require('bar.node')`,
- `export const foo = import.meta.require("bar.node")`
- );
- });
-
- it("require.resolve -> import.meta.resolveSync", () => {
- expectBunPrinted_(
- `export const foo = require.resolve('bar.node')`,
- `export const foo = import.meta.resolveSync("bar.node")`
- );
- });
-
- it('require.resolve(path, {paths: ["blah"]}) -> import.meta.resolveSync', () => {
- expectBunPrinted_(
- `export const foo = require.resolve('bar.node', {paths: ["blah"]})`,
- `export const foo = import.meta.resolveSync("bar.node", { paths: ["blah"] })`
- );
- });
- });
-
- describe("Browsers", () => {
- it('require.resolve("my-module") -> "/resolved/my-module"', () => {
- // the module resolver & linker doesn't run with Bun.Transpiler
- // so in this test, it becomes the same path string
- expectPrinted_(
- `export const foo = require.resolve('my-module')`,
- `export const foo = "my-module"`
- );
- });
- });
-
- it("define", () => {
- expectPrinted_(
- `export default typeof user_undefined === 'undefined';`,
- `export default true`
- );
- expectPrinted_(
- `export default typeof user_undefined !== 'undefined';`,
- `export default false`
- );
-
- expectPrinted_(
- `export default typeof user_undefined !== 'undefined';`,
- `export default false`
- );
- expectPrinted_(`export default !user_undefined;`, `export default true`);
- });
-
- it("decls", () => {
- // expectParseError("var x = 0", "");
- // expectParseError("let x = 0", "");
- // expectParseError("const x = 0", "");
- // expectParseError("for (var x = 0;;) ;", "");
- // expectParseError("for (let x = 0;;) ;", "");
- // expectParseError("for (const x = 0;;) ;", "");
-
- // expectParseError("for (var x in y) ;", "");
- // expectParseError("for (let x in y) ;", "");
- // expectParseError("for (const x in y) ;", "");
- // expectParseError("for (var x of y) ;", "");
- // expectParseError("for (let x of y) ;", "");
- // expectParseError("for (const x of y) ;", "");
-
- // expectParseError("var x", "");
- // expectParseError("let x", "");
- expectParseError("const x", 'The constant "x" must be initialized');
- expectParseError("const {}", "This constant must be initialized");
- expectParseError("const []", "This constant must be initialized");
- // expectParseError("for (var x;;) ;", "");
- // expectParseError("for (let x;;) ;", "");
- expectParseError(
- "for (const x;;) ;",
- 'The constant "x" must be initialized'
- );
- expectParseError(
- "for (const {};;) ;",
- "This constant must be initialized"
- );
- expectParseError(
- "for (const [];;) ;",
- "This constant must be initialized"
- );
-
- // Make sure bindings are visited during parsing
- expectPrinted_("var {[x]: y} = {}", "var { [x]: y } = {}");
- expectPrinted_("var {...x} = {}", "var { ...x } = {}");
-
- // Test destructuring patterns
- expectPrinted_("var [...x] = []", "var [...x] = []");
- expectPrinted_("var {...x} = {}", "var { ...x } = {}");
-
- expectPrinted_(
- "export var foo = ([...x] = []) => {}",
- "export var foo = ([...x] = []) => {\n}"
- );
-
- expectPrinted_(
- "export var foo = ({...x} = {}) => {}",
- "export var foo = ({ ...x } = {}) => {\n}"
- );
-
- expectParseError("var [...x,] = []", 'Unexpected "," after rest pattern');
- expectParseError("var {...x,} = {}", 'Unexpected "," after rest pattern');
- expectParseError(
- "export default function() { return ([...x,] = []) => {} }",
- "Unexpected trailing comma after rest element"
- );
- expectParseError(
- "({...x,} = {}) => {}",
- "Unexpected trailing comma after rest element"
- );
-
- expectPrinted_("[b, ...c] = d", "[b, ...c] = d");
- expectPrinted_("([b, ...c] = d)", "[b, ...c] = d");
- expectPrinted_("({b, ...c} = d)", "({ b, ...c } = d)");
- expectPrinted_("({a = b} = c)", "({ a = b } = c)");
- expectPrinted_("({a: b = c} = d)", "({ a: b = c } = d)");
- expectPrinted_("({a: b.c} = d)", "({ a: b.c } = d)");
- expectPrinted_("[a = {}] = b", "[a = {}] = b");
- expectPrinted_("[[...a, b].x] = c", "[[...a, b].x] = c");
- expectPrinted_("[{...a, b}.x] = c", "[{ ...a, b }.x] = c");
- expectPrinted_("({x: [...a, b].x} = c)", "({ x: [...a, b].x } = c)");
- expectPrinted_("({x: {...a, b}.x} = c)", "({ x: { ...a, b }.x } = c)");
- expectPrinted_("[x = [...a, b]] = c", "[x = [...a, b]] = c");
- expectPrinted_("[x = {...a, b}] = c", "[x = { ...a, b }] = c");
- expectPrinted_("({x = [...a, b]} = c)", "({ x = [...a, b] } = c)");
- expectPrinted_("({x = {...a, b}} = c)", "({ x = { ...a, b } } = c)");
-
- expectPrinted_("(x = y)", "x = y");
- expectPrinted_("([] = [])", "[] = []");
- expectPrinted_("({} = {})", "({} = {})");
- expectPrinted_("([[]] = [[]])", "[[]] = [[]]");
- expectPrinted_("({x: {}} = {x: {}})", "({ x: {} } = { x: {} })");
- expectPrinted_("(x) = y", "x = y");
- expectParseError("([]) = []", "Invalid assignment target");
- expectParseError("({}) = {}", "Invalid assignment target");
- expectParseError("[([])] = [[]]", "Invalid assignment target");
- expectParseError("({x: ({})} = {x: {}})", "Invalid assignment target");
- expectParseError(
- "(([]) = []) => {}",
- "Unexpected parentheses in binding pattern"
- );
- expectParseError(
- "(({}) = {}) => {}",
- "Unexpected parentheses in binding pattern"
- );
- expectParseError("function f(([]) = []) {}", "Parse error");
- expectParseError(
- "function f(({}) = {}) {}",
- "Parse error"
- // 'Expected identifier but found "("\n'
- );
-
- expectPrinted_("for (x in y) ;", "for (x in y) {\n}");
- expectPrinted_("for ([] in y) ;", "for ([] in y) {\n}");
- expectPrinted_("for ({} in y) ;", "for ({} in y) {\n}");
- expectPrinted_("for ((x) in y) ;", "for (x in y) {\n}");
- expectParseError("for (([]) in y) ;", "Invalid assignment target");
- expectParseError("for (({}) in y) ;", "Invalid assignment target");
-
- expectPrinted_("for (x of y) ;", "for (x of y) {\n}");
- expectPrinted_("for ([] of y) ;", "for ([] of y) {\n}");
- expectPrinted_("for ({} of y) ;", "for ({} of y) {\n}");
- expectPrinted_("for ((x) of y) ;", "for (x of y) {\n}");
- expectParseError("for (([]) of y) ;", "Invalid assignment target");
- expectParseError("for (({}) of y) ;", "Invalid assignment target");
-
- expectParseError("[[...a, b]] = c", 'Unexpected "," after rest pattern');
- expectParseError("[{...a, b}] = c", 'Unexpected "," after rest pattern');
- expectParseError(
- "({x: [...a, b]} = c)",
- 'Unexpected "," after rest pattern'
- );
- expectParseError(
- "({x: {...a, b}} = c)",
- 'Unexpected "," after rest pattern'
- );
- expectParseError("[b, ...c,] = d", 'Unexpected "," after rest pattern');
- expectParseError("([b, ...c,] = d)", 'Unexpected "," after rest pattern');
- expectParseError("({b, ...c,} = d)", 'Unexpected "," after rest pattern');
- expectParseError("({a = b})", 'Unexpected "="');
- expectParseError("({x = {a = b}} = c)", 'Unexpected "="');
- expectParseError("[a = {b = c}] = d", 'Unexpected "="');
-
- expectPrinted_(
- "for ([{a = {}}] in b) {}",
- "for ([{ a = {} }] in b) {\n}"
- );
- expectPrinted_(
- "for ([{a = {}}] of b) {}",
- "for ([{ a = {} }] of b) {\n}"
- );
- expectPrinted_("for ({a = {}} in b) {}", "for ({ a = {} } in b) {\n}");
- expectPrinted_("for ({a = {}} of b) {}", "for ({ a = {} } of b) {\n}");
-
- expectParseError("({a = {}} in b)", 'Unexpected "="');
- expectParseError("[{a = {}}]\nof()", 'Unexpected "="');
- expectParseError(
- "for ([...a, b] in c) {}",
- 'Unexpected "," after rest pattern'
- );
- expectParseError(
- "for ([...a, b] of c) {}",
- 'Unexpected "," after rest pattern'
- );
- });
-
- it("regexp", () => {
- expectPrinted("/x/g", "/x/g");
- expectPrinted("/x/i", "/x/i");
- expectPrinted("/x/m", "/x/m");
- expectPrinted("/x/s", "/x/s");
- expectPrinted("/x/u", "/x/u");
- expectPrinted("/x/y", "/x/y");
- expectPrinted("/gimme/g", "/gimme/g");
- expectPrinted("/gimgim/g", "/gimgim/g");
-
- expectParseError(
- "/x/msuygig",
- 'Duplicate flag "g" in regular expression'
- );
- });
-
- it("identifier escapes", () => {
- expectPrinted_("var _\u0076\u0061\u0072", "var _var");
- expectParseError(
- "var \u0076\u0061\u0072",
- 'Expected identifier but found "\u0076\u0061\u0072"'
- );
- expectParseError(
- "\\u0076\\u0061\\u0072 foo",
- "Unexpected \\u0076\\u0061\\u0072"
- );
-
- expectPrinted_("foo._\u0076\u0061\u0072", "foo._var");
- expectPrinted_("foo.\u0076\u0061\u0072", "foo.var");
-
- // expectParseError("\u200Ca", 'Unexpected "\\u200c"');
- // expectParseError("\u200Da", 'Unexpected "\\u200d"');
- });
- });
-
- it("private identifiers", () => {
- expectParseError("#foo", "Unexpected #foo");
- expectParseError("#foo in this", "Unexpected #foo");
- expectParseError("this.#foo", 'Expected identifier but found "#foo"');
- expectParseError("this?.#foo", 'Expected identifier but found "#foo"');
- expectParseError("({ #foo: 1 })", 'Expected identifier but found "#foo"');
- expectParseError(
- "class Foo { x = { #foo: 1 } }",
- 'Expected identifier but found "#foo"'
- );
- expectParseError("class Foo { x = #foo }", 'Expected "in" but found "}"');
- expectParseError(
- "class Foo { #foo; foo() { delete this.#foo } }",
- 'Deleting the private name "#foo" is forbidden'
- );
- expectParseError(
- "class Foo { #foo; foo() { delete this?.#foo } }",
- 'Deleting the private name "#foo" is forbidden'
- );
- expectParseError(
- "class Foo extends Bar { #foo; foo() { super.#foo } }",
- 'Expected identifier but found "#foo"'
- );
- expectParseError(
- "class Foo { #foo = () => { for (#foo in this) ; } }",
- "Unexpected #foo"
- );
- expectParseError(
- "class Foo { #foo = () => { for (x = #foo in this) ; } }",
- "Unexpected #foo"
- );
- expectPrinted_("class Foo { #foo }", "class Foo {\n #foo;\n}");
- expectPrinted_("class Foo { #foo = 1 }", "class Foo {\n #foo = 1;\n}");
- expectPrinted_(
- "class Foo { #foo = #foo in this }",
- "class Foo {\n #foo = #foo in this;\n}"
- );
- expectPrinted_(
- "class Foo { #foo = #foo in (#bar in this); #bar }",
- "class Foo {\n #foo = #foo in (#bar in this);\n #bar;\n}"
- );
- expectPrinted_(
- "class Foo { #foo() {} }",
- "class Foo {\n #foo() {\n }\n}"
- );
- expectPrinted_(
- "class Foo { get #foo() {} }",
- "class Foo {\n get #foo() {\n }\n}"
- );
- expectPrinted_(
- "class Foo { set #foo(x) {} }",
- "class Foo {\n set #foo(x) {\n }\n}"
- );
- expectPrinted_(
- "class Foo { static #foo }",
- "class Foo {\n static #foo;\n}"
- );
- expectPrinted_(
- "class Foo { static #foo = 1 }",
- "class Foo {\n static #foo = 1;\n}"
- );
- expectPrinted_(
- "class Foo { static #foo() {} }",
- "class Foo {\n static #foo() {\n }\n}"
- );
- expectPrinted_(
- "class Foo { static get #foo() {} }",
- "class Foo {\n static get #foo() {\n }\n}"
- );
- expectPrinted_(
- "class Foo { static set #foo(x) {} }",
- "class Foo {\n static set #foo(x) {\n }\n}"
- );
-
- expectParseError(
- "class Foo { #foo = #foo in #bar in this; #bar }",
- "Unexpected #bar"
- );
-
- expectParseError(
- "class Foo { #constructor }",
- 'Invalid field name "#constructor"'
- );
- expectParseError(
- "class Foo { #constructor() {} }",
- 'Invalid method name "#constructor"'
- );
- expectParseError(
- "class Foo { static #constructor }",
- 'Invalid field name "#constructor"'
- );
- expectParseError(
- "class Foo { static #constructor() {} }",
- 'Invalid method name "#constructor"'
- );
- expectParseError(
- "class Foo { #\\u0063onstructor }",
- 'Invalid field name "#constructor"'
- );
- expectParseError(
- "class Foo { #\\u0063onstructor() {} }",
- 'Invalid method name "#constructor"'
- );
- expectParseError(
- "class Foo { static #\\u0063onstructor }",
- 'Invalid field name "#constructor"'
- );
- expectParseError(
- "class Foo { static #\\u0063onstructor() {} }",
- 'Invalid method name "#constructor"'
- );
- const errorText = '"#foo" has already been declared';
- expectParseError("class Foo { #foo; #foo }", errorText);
- expectParseError("class Foo { #foo; static #foo }", errorText);
- expectParseError("class Foo { static #foo; #foo }", errorText);
- expectParseError("class Foo { #foo; #foo() {} }", errorText);
- expectParseError("class Foo { #foo; get #foo() {} }", errorText);
- expectParseError("class Foo { #foo; set #foo(x) {} }", errorText);
- expectParseError("class Foo { #foo() {} #foo }", errorText);
- expectParseError("class Foo { get #foo() {} #foo }", errorText);
- expectParseError("class Foo { set #foo(x) {} #foo }", errorText);
- expectParseError("class Foo { get #foo() {} get #foo() {} }", errorText);
- expectParseError("class Foo { set #foo(x) {} set #foo(x) {} }", errorText);
- expectParseError(
- "class Foo { get #foo() {} set #foo(x) {} #foo }",
- errorText
- );
- expectParseError(
- "class Foo { set #foo(x) {} get #foo() {} #foo }",
- errorText
- );
-
- expectPrinted_(
- "class Foo { get #foo() {} set #foo(x) { this.#foo } }",
- "class Foo {\n get #foo() {\n }\n set #foo(x) {\n this.#foo;\n }\n}"
- );
- expectPrinted_(
- "class Foo { set #foo(x) { this.#foo } get #foo() {} }",
- "class Foo {\n set #foo(x) {\n this.#foo;\n }\n get #foo() {\n }\n}"
- );
- expectPrinted_(
- "class Foo { #foo } class Bar { #foo }",
- "class Foo {\n #foo;\n}\n\nclass Bar {\n #foo;\n}"
- );
- expectPrinted_(
- "class Foo { foo = this.#foo; #foo }",
- "class Foo {\n foo = this.#foo;\n #foo;\n}"
- );
- expectPrinted_(
- "class Foo { foo = this?.#foo; #foo }",
- "class Foo {\n foo = this?.#foo;\n #foo;\n}"
- );
- expectParseError(
- "class Foo { #foo } class Bar { foo = this.#foo }",
- 'Private name "#foo" must be declared in an enclosing class'
- );
- expectParseError(
- "class Foo { #foo } class Bar { foo = this?.#foo }",
- 'Private name "#foo" must be declared in an enclosing class'
- );
- expectParseError(
- "class Foo { #foo } class Bar { foo = #foo in this }",
- 'Private name "#foo" must be declared in an enclosing class'
- );
-
- expectPrinted_(
- `class Foo {
- #if
- #im() { return this.#im(this.#if) }
- static #sf
- static #sm() { return this.#sm(this.#sf) }
- foo() {
- return class {
- #inner() {
- return [this.#im, this?.#inner, this?.x.#if]
- }
- }
- }
-}
-`,
- `class Foo {
- #if;
- #im() {
- return this.#im(this.#if);
- }
- static #sf;
- static #sm() {
- return this.#sm(this.#sf);
- }
- foo() {
- return class {
- #inner() {
- return [this.#im, this?.#inner, this?.x.#if];
- }
- };
- }
-}`
- );
- });
-
- it("type only exports", () => {
- let { expectPrinted_, expectParseError } = ts;
- expectPrinted_("export type {foo, bar as baz} from 'bar'", "");
- expectPrinted_("export type {foo, bar as baz}", "");
- expectPrinted_("export type {foo} from 'bar'; x", "x");
- expectPrinted_("export type {foo} from 'bar'\nx", "x");
- expectPrinted_("export type {default} from 'bar'", "");
- expectPrinted_(
- "export { type } from 'mod'; type",
- 'export { type } from "mod";\ntype'
- );
- expectPrinted_(
- "export { type, as } from 'mod'",
- 'export { type, as } from "mod"'
- );
- expectPrinted_(
- "export { x, type foo } from 'mod'; x",
- 'export { x } from "mod";\nx'
- );
- expectPrinted_(
- "export { x, type as } from 'mod'; x",
- 'export { x } from "mod";\nx'
- );
- expectPrinted_(
- "export { x, type foo as bar } from 'mod'; x",
- 'export { x } from "mod";\nx'
- );
- expectPrinted_(
- "export { x, type foo as as } from 'mod'; x",
- 'export { x } from "mod";\nx'
- );
- expectPrinted_(
- "export { type as as } from 'mod'; as",
- 'export { type as as } from "mod";\nas'
- );
- expectPrinted_(
- "export { type as foo } from 'mod'; foo",
- 'export { type as foo } from "mod";\nfoo'
- );
- expectPrinted_(
- "export { type as type } from 'mod'; type",
- 'export { type } from "mod";\ntype'
- );
- expectPrinted_(
- "export { x, type as as foo } from 'mod'; x",
- 'export { x } from "mod";\nx'
- );
- expectPrinted_(
- "export { x, type as as as } from 'mod'; x",
- 'export { x } from "mod";\nx'
- );
- expectPrinted_(
- "export { x, type type as as } from 'mod'; x",
- 'export { x } from "mod";\nx'
- );
- expectPrinted_(
- "export { x, \\u0074ype y }; let x, y",
- "export { x };\nlet x, y"
- );
- expectPrinted_(
- "export { x, \\u0074ype y } from 'mod'",
- 'export { x } from "mod"'
- );
- expectPrinted_(
- "export { x, type if } from 'mod'",
- 'export { x } from "mod"'
- );
- expectPrinted_("export { x, type y as if }; let x", "export { x };\nlet x");
- expectPrinted_("export { type x };", "");
- });
-
- it("delete + optional chain", () => {
- expectPrinted_("delete foo.bar.baz", "delete foo.bar.baz");
- expectPrinted_("delete foo?.bar.baz", "delete foo?.bar.baz");
- expectPrinted_("delete foo?.bar?.baz", "delete foo?.bar?.baz");
- });
-
- it("useDefineForConst TypeScript class initialization", () => {
- var { expectPrinted_ } = ts;
- expectPrinted_(
- `
-class Foo {
- constructor(public x: string = "hey") {}
- bar: number;
-}
-`.trim(),
- `
-class Foo {
- x;
- constructor(x = "hey") {
- this.x = x;
- }
- bar;
-}
-`.trim()
- );
- });
-
- it("class static blocks", () => {
- expectPrinted_(
- "class Foo { static {} }",
- "class Foo {\n static {\n }\n}"
- );
- expectPrinted_(
- "class Foo { static {} x = 1 }",
- "class Foo {\n static {\n }\n x = 1;\n}"
- );
- expectPrinted_(
- "class Foo { static { this.foo() } }",
- "class Foo {\n static {\n this.foo();\n }\n}"
- );
-
- expectParseError(
- "class Foo { static { yield } }",
- '"yield" is a reserved word and cannot be used in strict mode'
- );
- expectParseError(
- "class Foo { static { await } }",
- 'The keyword "await" cannot be used here'
- );
- expectParseError(
- "class Foo { static { return } }",
- "A return statement cannot be used here"
- );
- expectParseError(
- "class Foo { static { break } }",
- 'Cannot use "break" here'
- );
- expectParseError(
- "class Foo { static { continue } }",
- 'Cannot use "continue" here'
- );
- expectParseError(
- "x: { class Foo { static { break x } } }",
- 'There is no containing label named "x"'
- );
- expectParseError(
- "x: { class Foo { static { continue x } } }",
- 'There is no containing label named "x"'
- );
-
- expectParseError(
- "class Foo { get #x() { this.#x = 1 } }",
- 'Writing to getter-only property "#x" will throw'
- );
- expectParseError(
- "class Foo { get #x() { this.#x += 1 } }",
- 'Writing to getter-only property "#x" will throw'
- );
- expectParseError(
- "class Foo { set #x(x) { this.#x } }",
- 'Reading from setter-only property "#x" will throw'
- );
- expectParseError(
- "class Foo { set #x(x) { this.#x += 1 } }",
- 'Reading from setter-only property "#x" will throw'
- );
-
- // Writing to method warnings
- expectParseError(
- "class Foo { #x() { this.#x = 1 } }",
- 'Writing to read-only method "#x" will throw'
- );
- expectParseError(
- "class Foo { #x() { this.#x += 1 } }",
- 'Writing to read-only method "#x" will throw'
- );
- });
-
- describe("simplification", () => {
- it("unary operator", () => {
- expectPrinted("a = !(b, c)", "a = (b , !c)");
- });
-
- it("constant folding", () => {
- expectPrinted("1 && 2", "2");
- expectPrinted("1 || 2", "1");
- expectPrinted("0 && 1", "0");
- expectPrinted("0 || 1", "1");
-
- expectPrinted("null ?? 1", "1");
- expectPrinted("undefined ?? 1", "1");
- expectPrinted("0 ?? 1", "0");
- expectPrinted("false ?? 1", "false");
- expectPrinted('"" ?? 1', '""');
-
- expectPrinted("typeof undefined", '"undefined"');
- expectPrinted("typeof null", '"object"');
- expectPrinted("typeof false", '"boolean"');
- expectPrinted("typeof true", '"boolean"');
- expectPrinted("typeof 123", '"number"');
- expectPrinted("typeof 123n", '"bigint"');
- expectPrinted("typeof 'abc'", '"string"');
- expectPrinted("typeof function() {}", '"function"');
- expectPrinted("typeof (() => {})", '"function"');
- expectPrinted("typeof {}", "typeof {}");
- expectPrinted("typeof []", "typeof []");
-
- expectPrinted("undefined === undefined", "true");
- expectPrinted("undefined !== undefined", "false");
- expectPrinted("undefined == undefined", "true");
- expectPrinted("undefined != undefined", "false");
-
- expectPrinted("null === null", "true");
- expectPrinted("null !== null", "false");
- expectPrinted("null == null", "true");
- expectPrinted("null != null", "false");
-
- expectPrinted("undefined === null", "undefined === null");
- expectPrinted("undefined !== null", "undefined !== null");
- expectPrinted("undefined == null", "undefined == null");
- expectPrinted("undefined != null", "undefined != null");
-
- expectPrinted("true === true", "true");
- expectPrinted("true === false", "false");
- expectPrinted("true !== true", "false");
- expectPrinted("true !== false", "true");
- expectPrinted("true == true", "true");
- expectPrinted("true == false", "false");
- expectPrinted("true != true", "false");
- expectPrinted("true != false", "true");
-
- expectPrinted("1 === 1", "true");
- expectPrinted("1 === 2", "false");
- expectPrinted("1 === '1'", '1 === "1"');
- expectPrinted("1 == 1", "true");
- expectPrinted("1 == 2", "false");
- expectPrinted("1 == '1'", '1 == "1"');
-
- expectPrinted("1 !== 1", "false");
- expectPrinted("1 !== 2", "true");
- expectPrinted("1 !== '1'", '1 !== "1"');
- expectPrinted("1 != 1", "false");
- expectPrinted("1 != 2", "true");
- expectPrinted("1 != '1'", '1 != "1"');
-
- expectPrinted("'a' === '\\x61'", "true");
- expectPrinted("'a' === '\\x62'", "false");
- expectPrinted("'a' === 'abc'", "false");
- expectPrinted("'a' !== '\\x61'", "false");
- expectPrinted("'a' !== '\\x62'", "true");
- expectPrinted("'a' !== 'abc'", "true");
- expectPrinted("'a' == '\\x61'", "true");
- expectPrinted("'a' == '\\x62'", "false");
- expectPrinted("'a' == 'abc'", "false");
- expectPrinted("'a' != '\\x61'", "false");
- expectPrinted("'a' != '\\x62'", "true");
- expectPrinted("'a' != 'abc'", "true");
-
- expectPrinted("'a' + 'b'", '"ab"');
- expectPrinted("'a' + 'bc'", '"abc"');
- expectPrinted("'ab' + 'c'", '"abc"');
- expectPrinted("x + 'a' + 'b'", 'x + "ab"');
- expectPrinted("x + 'a' + 'bc'", 'x + "abc"');
- expectPrinted("x + 'ab' + 'c'", 'x + "abc"');
- expectPrinted("'a' + 1", '"a" + 1');
- expectPrinted("x * 'a' + 'b'", 'x * "a" + "b"');
-
- expectPrinted("'string' + `template`", `"stringtemplate"`);
-
- expectPrinted("`template` + 'string'", "`templatestring`");
-
- // TODO: string template simplification
- // expectPrinted("'string' + `a${foo}b`", "`stringa${foo}b`");
- // expectPrinted("'string' + tag`template`", '"string" + tag`template`;');
- // expectPrinted("`a${foo}b` + 'string'", "`a${foo}bstring`");
- // expectPrinted("tag`template` + 'string'", 'tag`template` + "string"');
- // expectPrinted("`template` + `a${foo}b`", "`templatea${foo}b`");
- // expectPrinted("`a${foo}b` + `template`", "`a${foo}btemplate`");
- // expectPrinted("`a${foo}b` + `x${bar}y`", "`a${foo}bx${bar}y`");
- // expectPrinted(
- // "`a${i}${j}bb` + `xxx${bar}yyyy`",
- // "`a${i}${j}bbxxx${bar}yyyy`"
- // );
- // expectPrinted(
- // "`a${foo}bb` + `xxx${i}${j}yyyy`",
- // "`a${foo}bbxxx${i}${j}yyyy`"
- // );
- // expectPrinted(
- // "`template` + tag`template2`",
- // "`template` + tag`template2`"
- // );
- // expectPrinted(
- // "tag`template` + `template2`",
- // "tag`template` + `template2`"
- // );
-
- expectPrinted("123", "123");
- expectPrinted("123 .toString()", "123 .toString()");
- expectPrinted("-123", "-123");
- expectPrinted("(-123).toString()", "(-123).toString()");
- expectPrinted("-0", "-0");
- expectPrinted("(-0).toString()", "(-0).toString()");
- expectPrinted("-0 === 0", "true");
-
- expectPrinted("NaN", "NaN");
- expectPrinted("NaN.toString()", "NaN.toString()");
- expectPrinted("NaN === NaN", "false");
-
- expectPrinted("Infinity", "Infinity");
- expectPrinted("Infinity.toString()", "Infinity.toString()");
- expectPrinted("(-Infinity).toString()", "(-Infinity).toString()");
- expectPrinted("Infinity === Infinity", "true");
- expectPrinted("Infinity === -Infinity", "false");
-
- expectPrinted("123n === 1_2_3n", "true");
- });
- describe("type coercions", () => {
- const dead = `
- if ("") {
- TEST_FAIL
- }
-
- if (false) {
- TEST_FAIL
- }
-
- if (0) {
- TEST_FAIL
- }
-
- if (void 0) {
- TEST_FAIL
- }
-
- if (null) {
- TEST_FAIL
- }
-
- var should_be_true = typeof "" === "string" || false
- var should_be_false = typeof "" !== "string" && TEST_FAIL;
- var should_be_false_2 = typeof true === "string" && TEST_FAIL;
- var should_be_false_3 = typeof false === "string" && TEST_FAIL;
- var should_be_false_4 = typeof 123n === "string" && TEST_FAIL;
- var should_be_false_5 = typeof function(){} === "string" && TEST_FAIL;
- var should_be_kept = typeof globalThis.BACON === "string" && TEST_OK;
- var should_be_kept_1 = typeof TEST_OK === "string";
-
- var should_be_kept_2 = TEST_OK ?? true;
- var should_be_kept_4 = { "TEST_OK": true } ?? TEST_FAIL;
- var should_be_false_6 = false ?? TEST_FAIL;
- var should_be_true_7 = true ?? TEST_FAIL;
- `;
- const out = transpiler.transformSync(dead);
-
- for (let line of out.split("\n")) {
- it(line, () => {
- if (line.includes("should_be_kept")) {
- expect(line.includes("TEST_OK")).toBe(true);
- }
-
- if (line.includes("should_be_false")) {
- if (!line.includes("= false"))
- throw new Error(`Expected false in "${line}"`);
- expect(line.includes("= false")).toBe(true);
- }
-
- if (line.includes("TEST_FAIL")) {
- throw new Error(`"${line}"\n\tshould not contain TEST_FAIL`);
- }
- });
- }
- });
- });
-
- describe("scan", () => {
- it("reports all export names", () => {
- const { imports, exports } = transpiler.scan(code);
-
- expect(exports[0]).toBe("action");
- expect(exports[2]).toBe("loader");
- expect(exports[1]).toBe("default");
- expect(exports).toHaveLength(3);
-
- expect(imports.filter(({ path }) => path === "remix")).toHaveLength(1);
- expect(imports.filter(({ path }) => path === "mod")).toHaveLength(0);
- expect(imports.filter(({ path }) => path === "react")).toHaveLength(1);
- expect(imports).toHaveLength(2);
- });
- });
-
- describe("transform", () => {
- it("supports macros", async () => {
- const out = await transpiler.transform(`
- import {keepSecondArgument} from 'macro:${
- import.meta.dir
- }/macro-check.js';
-
- export default keepSecondArgument("Test failed", "Test passed");
- export function otherNamesStillWork() {}
- `);
- expect(out.includes("Test failed")).toBe(false);
- expect(out.includes("Test passed")).toBe(true);
-
- // ensure both the import and the macro function call are removed
- expect(out.includes("keepSecondArgument")).toBe(false);
- expect(out.includes("otherNamesStillWork")).toBe(true);
- });
-
- it("sync supports macros", () => {
- const out = transpiler.transformSync(`
- import {keepSecondArgument} from 'macro:${
- import.meta.dir
- }/macro-check.js';
-
- export default keepSecondArgument("Test failed", "Test passed");
- export function otherNamesStillWork() {
-
- }
- `);
- expect(out.includes("Test failed")).toBe(false);
- expect(out.includes("Test passed")).toBe(true);
-
- expect(out.includes("keepSecondArgument")).toBe(false);
- expect(out.includes("otherNamesStillWork")).toBe(true);
- });
-
- const importLines = [
- "import {createElement, bacon} from 'react';",
- "import {bacon, createElement} from 'react';",
- ];
- describe("sync supports macros remap", () => {
- for (let importLine of importLines) {
- it(importLine, () => {
- var thisCode = `
- ${importLine}
-
- export default bacon("Test failed", "Test passed");
- export function otherNamesStillWork() {
- return createElement("div");
- }
-
- `;
- var out = transpiler.transformSync(thisCode);
- try {
- expect(out.includes("Test failed")).toBe(false);
- expect(out.includes("Test passed")).toBe(true);
-
- expect(out.includes("bacon")).toBe(false);
- expect(out.includes("createElement")).toBe(true);
- } catch (e) {
- console.log("Failing code:\n\n" + out + "\n");
- throw e;
- }
- });
- }
- });
-
- it("macro remap removes import statement if its the only used one", () => {
- const out = transpiler.transformSync(`
- import {bacon} from 'react';
-
- export default bacon("Test failed", "Test passed");
- `);
-
- expect(out.includes("Test failed")).toBe(false);
- expect(out.includes("Test passed")).toBe(true);
-
- expect(out.includes("bacon")).toBe(false);
- expect(out.includes("import")).toBe(false);
- });
-
- it("removes types", () => {
- expect(code.includes("mod")).toBe(true);
- expect(code.includes("xx")).toBe(true);
- expect(code.includes("ActionFunction")).toBe(true);
- expect(code.includes("LoaderFunction")).toBe(true);
- expect(code.includes("ReactNode")).toBe(true);
- expect(code.includes("React")).toBe(true);
- expect(code.includes("Component")).toBe(true);
- const out = transpiler.transformSync(code);
-
- expect(out.includes("ActionFunction")).toBe(false);
- expect(out.includes("LoaderFunction")).toBe(false);
- expect(out.includes("mod")).toBe(false);
- expect(out.includes("xx")).toBe(false);
- expect(out.includes("ReactNode")).toBe(false);
- const { exports } = transpiler.scan(out);
- exports.sort();
-
- expect(exports[0]).toBe("action");
- expect(exports[2]).toBe("loader");
- expect(exports[1]).toBe("default");
- expect(exports).toHaveLength(3);
- });
- });
-});
diff --git a/integration/bunjs-only-snippets/tsconfig.json b/integration/bunjs-only-snippets/tsconfig.json
deleted file mode 100644
index 9a6c36e06..000000000
--- a/integration/bunjs-only-snippets/tsconfig.json
+++ /dev/null
@@ -1,16 +0,0 @@
-{
- "compilerOptions": {
- "lib": ["ESNext"],
- "module": "esnext",
- "target": "esnext",
- "noEmit": true,
- "allowJs": true,
- "typeRoots": ["../../types"],
- "types": ["bun"],
- "allowSyntheticDefaultImports": true,
- "baseUrl": ".",
- "paths": {
- "foo/bar": ["baz.js"]
- }
- }
-}
diff --git a/integration/bunjs-only-snippets/unsafe.test.js b/integration/bunjs-only-snippets/unsafe.test.js
deleted file mode 100644
index 741dc0241..000000000
--- a/integration/bunjs-only-snippets/unsafe.test.js
+++ /dev/null
@@ -1,51 +0,0 @@
-import { test, expect, it, describe } from "bun:test";
-import { gc } from "./gc";
-
-it("arrayBufferToString u8", async () => {
- var encoder = new TextEncoder();
- const bytes = encoder.encode("hello world");
- gc(true);
- expect(Bun.unsafe.arrayBufferToString(bytes)).toBe("hello world");
- gc(true);
- await new Promise((resolve) => setTimeout(resolve, 0));
- gc(true);
-});
-
-it("arrayBufferToString ArrayBuffer", async () => {
- var encoder = new TextEncoder();
- var bytes = encoder.encode("hello world");
- gc(true);
- const out = Bun.unsafe.arrayBufferToString(bytes.buffer);
- expect(out).toBe("hello world");
- gc(true);
- await new Promise((resolve) => setTimeout(resolve, 0));
- globalThis.bytes = bytes;
- gc(true);
- expect(out).toBe("hello world");
-});
-
-it("arrayBufferToString u16", () => {
- var encoder = new TextEncoder();
- const bytes = encoder.encode("hello world");
- var uint16 = new Uint16Array(bytes.byteLength);
- uint16.set(bytes);
- const charCodes = Bun.unsafe
- .arrayBufferToString(uint16)
- .split("")
- .map((a) => a.charCodeAt(0));
- gc(true);
- for (let i = 0; i < charCodes.length; i++) {
- expect("hello world"[i]).toBe(String.fromCharCode(charCodes[i]));
- }
- gc(true);
- expect(charCodes.length).toBe("hello world".length);
- gc(true);
-});
-
-it("Bun.allocUnsafe", () => {
- var buffer = Bun.allocUnsafe(1024);
- expect(buffer instanceof Uint8Array).toBe(true);
- expect(buffer.length).toBe(1024);
- buffer[0] = 0;
- expect(buffer[0]).toBe(0);
-});
diff --git a/integration/bunjs-only-snippets/url.test.ts b/integration/bunjs-only-snippets/url.test.ts
deleted file mode 100644
index 37ea2008b..000000000
--- a/integration/bunjs-only-snippets/url.test.ts
+++ /dev/null
@@ -1,102 +0,0 @@
-import { describe, it, expect } from "bun:test";
-
-describe("url", () => {
- it("prints", () => {
- expect(Bun.inspect(new URL("https://example.com"))).toBe(
- "https://example.com/"
- );
-
- expect(
- Bun.inspect(
- new URL(
- "https://github.com/Jarred-Sumner/bun/issues/135?hello%20i%20have%20spaces%20thank%20you%20good%20night"
- )
- )
- ).toBe(
- "https://github.com/Jarred-Sumner/bun/issues/135?hello%20i%20have%20spaces%20thank%20you%20good%20night"
- );
- });
- it("works", () => {
- const inputs: [
- [
- string,
- {
- hash: string;
- host: string;
- hostname: string;
- href: string;
- origin: string;
- password: string;
- pathname: string;
- port: string;
- protocol: string;
- search: string;
- username: string;
- }
- ]
- ] = [
- [
- "https://username:password@api.foo.bar.com:9999/baz/okay/i/123?ran=out&of=things#to-use-as-a-placeholder",
- {
- hash: "#to-use-as-a-placeholder",
- host: "api.foo.bar.com:9999",
- hostname: "api.foo.bar.com",
- href: "https://username:password@api.foo.bar.com:9999/baz/okay/i/123?ran=out&of=things#to-use-as-a-placeholder",
- origin: "https://api.foo.bar.com:9999",
- password: "password",
- pathname: "/baz/okay/i/123",
- port: "9999",
- protocol: "https:",
- search: "?ran=out&of=things",
- username: "username",
- },
- ],
- [
- "https://url.spec.whatwg.org/#url-serializing",
- {
- hash: "#url-serializing",
- host: "url.spec.whatwg.org",
- hostname: "url.spec.whatwg.org",
- href: "https://url.spec.whatwg.org/#url-serializing",
- origin: "https://url.spec.whatwg.org",
- password: "",
- pathname: "/",
- port: "",
- protocol: "https:",
- search: "",
- username: "",
- },
- ],
- [
- "https://url.spec.whatwg.org#url-serializing",
- {
- hash: "#url-serializing",
- host: "url.spec.whatwg.org",
- hostname: "url.spec.whatwg.org",
- href: "https://url.spec.whatwg.org/#url-serializing",
- origin: "https://url.spec.whatwg.org",
- password: "",
- pathname: "/",
- port: "",
- protocol: "https:",
- search: "",
- username: "",
- },
- ],
- ];
-
- for (let [url, values] of inputs) {
- const result = new URL(url);
- expect(result.hash).toBe(values.hash);
- expect(result.host).toBe(values.host);
- expect(result.hostname).toBe(values.hostname);
- expect(result.href).toBe(values.href);
- expect(result.password).toBe(values.password);
- expect(result.pathname).toBe(values.pathname);
- expect(result.port).toBe(values.port);
- expect(result.protocol).toBe(values.protocol);
- expect(result.search).toBe(values.search);
- expect(result.username).toBe(values.username);
- }
- });
-});
diff --git a/integration/bunjs-only-snippets/wasm-return-1-test.zig b/integration/bunjs-only-snippets/wasm-return-1-test.zig
deleted file mode 100644
index d46bdae92..000000000
--- a/integration/bunjs-only-snippets/wasm-return-1-test.zig
+++ /dev/null
@@ -1,5 +0,0 @@
-export fn hello() i32 {
- return 1;
-}
-
-pub fn main() void {}
diff --git a/integration/bunjs-only-snippets/wasm.js b/integration/bunjs-only-snippets/wasm.js
deleted file mode 100644
index a4daaaffe..000000000
--- a/integration/bunjs-only-snippets/wasm.js
+++ /dev/null
@@ -1 +0,0 @@
-import * as wasm from "./wasm-return-1-test.wasm";
diff --git a/integration/bunjs-only-snippets/wasm.test.js b/integration/bunjs-only-snippets/wasm.test.js
deleted file mode 100644
index ab88d5beb..000000000
--- a/integration/bunjs-only-snippets/wasm.test.js
+++ /dev/null
@@ -1,20 +0,0 @@
-import { it } from "bun:test";
-// import * as wasm from "./wasm-return-1-test.wasm";
-
-// import { readFileSync } from "fs";
-
-// it("wasm readFileSync", async () => {
-// console.log("here");
-// console.log(wasm.hello());
-// });
-
-// it("wasm import", async () => {
-// console.log("heyt");
-// try {
-// console.log("hi");
-// expect(wasm.hello()).toBe(1);
-// } catch (err) {
-// console.error(err);
-// throw err;
-// }
-// });
diff --git a/integration/bunjs-only-snippets/web-globals.test.js b/integration/bunjs-only-snippets/web-globals.test.js
deleted file mode 100644
index ac7c22e84..000000000
--- a/integration/bunjs-only-snippets/web-globals.test.js
+++ /dev/null
@@ -1,46 +0,0 @@
-import { expect, test } from "bun:test";
-
-test("exists", () => {
- expect(typeof URL !== "undefined").toBe(true);
- expect(typeof URLSearchParams !== "undefined").toBe(true);
- expect(typeof DOMException !== "undefined").toBe(true);
- expect(typeof Event !== "undefined").toBe(true);
- expect(typeof EventTarget !== "undefined").toBe(true);
- expect(typeof AbortController !== "undefined").toBe(true);
- expect(typeof AbortSignal !== "undefined").toBe(true);
- expect(typeof CustomEvent !== "undefined").toBe(true);
- expect(typeof Headers !== "undefined").toBe(true);
- expect(typeof ErrorEvent !== "undefined").toBe(true);
- expect(typeof CloseEvent !== "undefined").toBe(true);
- expect(typeof MessageEvent !== "undefined").toBe(true);
- expect(typeof TextEncoder !== "undefined").toBe(true);
- expect(typeof WebSocket !== "undefined").toBe(true);
-});
-
-test("CloseEvent", () => {
- var event = new CloseEvent("close", { reason: "world" });
- expect(event.type).toBe("close");
- const target = new EventTarget();
- var called = false;
- target.addEventListener("close", ({ type, reason }) => {
- expect(type).toBe("close");
- expect(reason).toBe("world");
- called = true;
- });
- target.dispatchEvent(event);
- expect(called).toBe(true);
-});
-
-test("MessageEvent", () => {
- var event = new MessageEvent("message", { data: "world" });
- expect(event.type).toBe("message");
- const target = new EventTarget();
- var called = false;
- target.addEventListener("message", ({ type, data }) => {
- expect(type).toBe("message");
- expect(data).toBe("world");
- called = true;
- });
- target.dispatchEvent(event);
- expect(called).toBe(true);
-});
diff --git a/integration/bunjs-only-snippets/websocket.test.js b/integration/bunjs-only-snippets/websocket.test.js
deleted file mode 100644
index ab825fa63..000000000
--- a/integration/bunjs-only-snippets/websocket.test.js
+++ /dev/null
@@ -1,79 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { unsafe } from "bun";
-import { gc } from "./gc";
-
-const TEST_WEBSOCKET_HOST =
- process.env.TEST_WEBSOCKET_HOST || "wss://ws.postman-echo.com/raw";
-
-describe("WebSocket", () => {
- it("should connect", async () => {
- const ws = new WebSocket(TEST_WEBSOCKET_HOST);
- await new Promise((resolve, reject) => {
- ws.onopen = resolve;
- ws.onerror = reject;
- });
- var closed = new Promise((resolve, reject) => {
- ws.onclose = resolve;
- });
- ws.close();
- await closed;
- });
-
- it("should send and receive messages", async () => {
- const ws = new WebSocket(TEST_WEBSOCKET_HOST);
- await new Promise((resolve, reject) => {
- ws.onopen = resolve;
- ws.onerror = reject;
- ws.onclose = () => {
- reject("WebSocket closed");
- };
- });
- const count = 10;
-
- // 10 messages in burst
- var promise = new Promise((resolve, reject) => {
- var remain = count;
- ws.onmessage = (event) => {
- gc(true);
- expect(event.data).toBe("Hello World!");
- remain--;
-
- if (remain <= 0) {
- ws.onmessage = () => {};
- resolve();
- }
- };
- ws.onerror = reject;
- });
-
- for (let i = 0; i < count; i++) {
- ws.send("Hello World!");
- gc(true);
- }
-
- await promise;
- var echo = 0;
-
- // 10 messages one at a time
- function waitForEcho() {
- return new Promise((resolve, reject) => {
- gc(true);
- const msg = `Hello World! ${echo++}`;
- ws.onmessage = (event) => {
- expect(event.data).toBe(msg);
- resolve();
- };
- ws.onerror = reject;
- ws.onclose = reject;
- ws.send(msg);
- gc(true);
- });
- }
- gc(true);
- for (let i = 0; i < count; i++) await waitForEcho();
- ws.onclose = () => {};
- ws.onerror = () => {};
- ws.close();
- gc(true);
- });
-});
diff --git a/integration/bunjs-only-snippets/writeFileSync.txt b/integration/bunjs-only-snippets/writeFileSync.txt
deleted file mode 100644
index a0fe4515f..000000000
--- a/integration/bunjs-only-snippets/writeFileSync.txt
+++ /dev/null
@@ -1 +0,0 @@
-File
\ No newline at end of file
diff --git a/integration/bunjs-only-snippets/zlib.test.js b/integration/bunjs-only-snippets/zlib.test.js
deleted file mode 100644
index aecb095cc..000000000
--- a/integration/bunjs-only-snippets/zlib.test.js
+++ /dev/null
@@ -1,18 +0,0 @@
-import { describe, it, expect } from "bun:test";
-import { gzipSync, deflateSync, inflateSync, gunzipSync } from "bun";
-
-describe("zlib", () => {
- it("should be able to deflate and inflate", () => {
- const data = new TextEncoder().encode("Hello World!".repeat(1));
- const compressed = deflateSync(data);
- const decompressed = inflateSync(compressed);
- expect(decompressed.join("")).toBe(data.join(""));
- });
-
- it("should be able to gzip and gunzip", () => {
- const data = new TextEncoder().encode("Hello World!".repeat(1));
- const compressed = gzipSync(data);
- const decompressed = gunzipSync(compressed);
- expect(decompressed.join("")).toBe(data.join(""));
- });
-});
--
cgit v1.2.3