swc-project/swc
1
1
Fork 0
mirror of https://github.com/swc-project/swc.git synced 2024-12-19 19:52:21 +03:00
Code Issues Actions 5 Packages Projects Releases Wiki Activity
2b292e6d17
swc/ecmascript/transforms/tests/decorators.rs
Donny/강동윤 e46a842e99
feat(es/parser, es/transform): Implement ergonomic brand checking (#2079) 
swc_ecma_parser:
 - Implement parsing of private properties in object literals.

swc_ecma_transforms_base:
 - `fixer`: Handle `const [a = (b, c)]`.

swc_ecma_transforms_compat:
 - `class_properties`: Support ergonomic brand checks. (#2064)

swc_ecma_transforms_proposal:
 - Implement ergonomic brand checks for private fields. (#2064)
2021-09-27 08:03:48 +00:00

6014 lines
125 KiB
Rust
Raw Blame History

#![cfg(all(
feature = "swc_ecma_transforms_compat",
feature = "swc_ecma_transforms_module",
feature = "swc_ecma_transforms_optimization",
feature = "swc_ecma_transforms_proposal",
))]
use swc_common::{chain, Mark};
use swc_ecma_parser::{EsConfig, Syntax, TsConfig};
use swc_ecma_transforms_base::resolver::resolver;
use swc_ecma_transforms_compat::{
es2015::{classes, function_name},
es2020::class_properties,
};
use swc_ecma_transforms_module::common_js;
use swc_ecma_transforms_optimization::simplify::inlining;
use swc_ecma_transforms_proposal::{decorators, decorators::Config};
use swc_ecma_transforms_testing::{test, test_exec};
use swc_ecma_transforms_typescript::strip;
use swc_ecma_visit::Fold;
fn ts() -> Syntax {
Syntax::Typescript(TsConfig {
decorators: true,
..Default::default()
})
}
fn syntax(decorators_before_export: bool) -> Syntax {
Syntax::Es(EsConfig {
decorators_before_export,
decorators: true,
class_props: true,
..Default::default()
})
}
fn tr() -> impl Fold {
chain!(
decorators(Default::default()),
class_properties(class_properties::Config { loose: false }),
)
}
fn ts_transform() -> impl Fold {
chain!(
decorators(Config {
legacy: true,
..Default::default()
}),
simple_strip(),
)
}
fn simple_strip() -> impl Fold {
strip::strip_with_config(strip::Config {
no_empty_export: true,
..Default::default()
})
}
/// Folder for `transformation_*` tests
fn transformation() -> impl Fold {
chain!(decorators(Default::default()), simple_strip(),)
}
// transformation_declaration
test!(
syntax(false),
|_| transformation(),
transformation_declaration,
r#"
@dec()
class A {}
"#,
r#"
let A = _decorate([dec()], function (_initialize) {
class A {
constructor() {
_initialize(this);
}
}
return {
F: A,
d: []
};
});
"#
);
// transformation_initialize_after_super_multiple
test!(
syntax(false),
|_| transformation(),
transformation_initialize_after_super_multiple,
r#"
@dec
class B extends A {
constructor() {
const foo = () => { super(); };
if (a) { super(); }
else { foo(); }
while (0) { super(); }
super();
}
}
"#,
r#"
let B = _decorate([dec], function (_initialize, _A) {
class B extends _A {
constructor() {
const foo = () => {
super();
_initialize(this);
};
if (a) {
super();
_initialize(this);
} else {
foo();
}
while (0) {
super();
_initialize(this);
}
super();
_initialize(this);
}
}
return {
F: B,
d: []
};
}, A);
"#
);
// transformation_export_default_anonymous
test!(
syntax(false),
|_| transformation(),
transformation_export_default_anonymous,
r#"
export default @dec() class {}
"#,
r#"
export default _decorate([dec()], function (_initialize) {
class _class {
constructor() {
_initialize(this);
}
}
return {
F: _class,
d: []
};
});
"#
);
// transformation_initialize_after_super_statement
test!(
syntax(false),
|_| transformation(),
transformation_initialize_after_super_statement,
r#"
@dec
class B extends A {
constructor() {
super();
}
}
"#,
r#"
let B = _decorate([dec], function (_initialize, _A) {
class B extends _A {
constructor() {
super();
_initialize(this);
}
}
return {
F: B,
d: []
};
}, A);
"#
);
// element_descriptors_created_own_method_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_created_own_method_exec,
r#"
function pushElement(e) {
return function (c) { c.elements.push(e); return c };
}
function method() {}
@pushElement({
kind: "method",
placement: "own",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: method,
}
})
class A {}
expect(A).not.toHaveProperty("foo");
expect(A.prototype).not.toHaveProperty("foo");
expect(Object.getOwnPropertyDescriptor(new A(), "foo")).toEqual({
enumerable: true,
configurable: true,
writable: true,
value: method,
});
"#
);
// finishers_return_class_exec
test_exec!(
syntax(false),
|_| tr(),
finishers_return_class_exec,
r#"
class C {}
function decorator(el) {
return Object.assign(el, {
finisher() {
return C;
},
});
}
class A {
@decorator
foo() {}
}
expect(A).toBe(C);
"#
);
// misc_method_name_not_shadow
test!(
syntax(false),
|_| tr(),
misc_method_name_not_shadow,
r#"
var method = 1;
@decorator
class Foo {
method() {
return method;
}
}
"#,
r#"
var method = 1;
let Foo = _decorate([decorator], function (_initialize) {
class Foo {
constructor() {
_initialize(this);
}
}
return {
F: Foo,
d: [{
kind: "method",
key: "method",
value: function method1() {
return method;
}
}]
};
});
"#
);
// element_descriptors_original_class_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_original_class_exec,
r#"
var el = null;
@(_ => el = _)
class A {}
expect(el).toEqual(Object.defineProperty({
kind: "class",
elements: []
}, Symbol.toStringTag, { value: "Descriptor" }));
@(_ => el = _)
class B {
foo = 2;
static bar() {}
get baz() {}
set baz(x) {}
}
expect(el.elements).toHaveLength(3);
"#
);
// duplicated_keys_create_existing_element_with_extras_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_create_existing_element_with_extras_exec,
r#"
function decorate(el) {
el.extras = [{
kind: "method",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: function() {},
}
}];
return el;
}
expect(() => {
class A {
@decorate
bar() {}
foo() {}
}
}).toThrow(TypeError);
"#
);
// finishers_no_in_extras_exec
test_exec!(
syntax(false),
|_| tr(),
finishers_no_in_extras_exec,
r#"
class C {}
function decorator(el) {
return Object.assign(el, {
extras: [
Object.assign({}, el, {
key: "bar",
finisher() {
return C;
}
})
]
});
}
expect(() => {
class A {
@decorator
foo() {}
}
}).toThrow();
"#
);
// duplicated_keys_computed_keys_same_value
test!(
syntax(false),
|_| tr(),
duplicated_keys_computed_keys_same_value,
r#"
@(_ => desc = _)
class Foo {
[getKeyI()]() {
return 1;
}
[getKeyJ()]() {
return 2;
}
}
"#,
r#"
let Foo = _decorate([_ => desc = _], function (_initialize) {
class Foo {
constructor() {
_initialize(this);
}
}
return {
F: Foo,
d: [{
kind: "method",
key: getKeyI(),
value: function () {
return 1;
}
}, {
kind: "method",
key: getKeyJ(),
value: function () {
return 2;
}
}]
};
});
"#
);
// transformation_only_decorated
test!(
syntax(false),
|_| transformation(),
transformation_only_decorated,
r#"
class B {
foo = 2;
bar() {}
}
"#,
r#"
class B {
bar() {}
constructor() {
this.foo = 2;
}
}
"#
);
// ordering_finishers_exec
test_exec!(
syntax(false),
|_| tr(),
ordering_finishers_exec,
r#"
var log = [];
function push(x) { log.push(x); return x; }
function logFinisher(x) {
return function (el) {
return Object.assign(el, {
finisher() { push(x); }
});
};
}
@logFinisher(9)
@logFinisher(8)
class A {
@logFinisher(1)
@logFinisher(0)
foo;
@logFinisher(3)
@logFinisher(2)
static bar() {}
@logFinisher(5)
@logFinisher(4)
static baz;
@logFinisher(7)
@logFinisher(6)
asd() {}
}
var numsFrom0to9 = Array.from({ length: 10 }, (_, i) => i);
expect(log).toEqual(numsFrom0to9);
"#
);
// transformation_initiailzer_after_super_bug_8808
test!(
syntax(false),
|_| transformation(),
transformation_initiailzer_after_super_bug_8808,
r#"
@decorator(parameter)
class Sub extends Super {
constructor() {
super().method();
}
}
"#,
r#"
let Sub = _decorate([decorator(parameter)], function (_initialize, _Super) {
class Sub extends _Super {
constructor() {
var _temp;
(_temp = super(), _initialize(this), _temp).method();
}
}
return {
F: Sub,
d: []
};
}, Super);
"#
);
// duplicated_keys_original_method_overwritten_no_decorators_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_original_method_overwritten_no_decorators_exec,
r#"
var el;
@(_ => el = _)
class A {
method() {
return 1;
}
method() {
return 2;
}
}
expect(el.elements).toHaveLength(1);
expect(A.prototype.method()).toBe(2);
"#
);
// transformation_arguments
test!(
syntax(false),
|_| transformation(),
transformation_arguments,
r#"
@dec(a, b, ...c)
class A {
@dec(a, b, ...c) method() {}
}
"#,
r#"
let A = _decorate([dec(a, b, ...c)], function (_initialize) {
class A {
constructor() {
_initialize(this);
}
}
return {
F: A,
d: [{
kind: "method",
decorators: [dec(a, b, ...c)],
key: "method",
value: function method() {}
}]
};
});
"#
);
// duplicated_keys_original_method_overwritten_both_decorated_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_original_method_overwritten_both_decorated_exec,
r#"
expect(() => {
class A {
@(el => el)
method() {
return 1;
}
@(el => el)
method() {
return 2;
}
}
}).toThrow(ReferenceError);
"#
);
// ordering_field_initializers_after_methods_exec
test_exec!(
// Babel 7.3.0 fails
ignore,
syntax(false),
|_| tr(),
ordering_field_initializers_after_methods_exec,
r#"
var counter = 0;
@(x => x)
class A {
foo = (() => {
counter++;
expect(typeof this.method).toBe("function");
expect(this.foo).toBeUndefined();
expect(this.bar).toBeUndefined();
return "foo";
})();
method() {}
bar = (() => {
counter++;
expect(typeof this.method).toBe("function");
expect(this.foo).toBe("foo");
expect(this.bar).toBeUndefined();
})();
}
expect(counter).toBe(0);
new A();
expect(counter).toBe(2);
"#
);
// misc_to_primitive_exec
test_exec!(
syntax(false),
|_| tr(),
misc_to_primitive_exec,
r#"
let calls = 0;
const baz = {
[Symbol.toPrimitive]() {
calls++;
return "baz";
}
}
function dec() {}
@dec
class A {
[baz]() {}
}
expect(calls).toBe(1);
"#
);
// ordering
// transformation_initialize_after_super_expression
test!(
syntax(false),
|_| transformation(),
transformation_initialize_after_super_expression,
r#"
@dec
class B extends A {
constructor() {
(0, super());
}
}
"#,
r#"
let B = _decorate([dec], function (_initialize, _A) {
class B extends _A {
constructor() {
var _temp;
_temp = super(), _initialize(this), _temp;
}
}
return {
F: B,
d: []
};
}, A);
"#
);
// element_descriptors_not_reused_field_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_not_reused_field_exec,
r#"
var dec1, dec2;
class A {
@(_ => dec1 = _)
@(_ => dec2 = _)
field = {}
}
expect(dec1).toEqual(dec2);
expect(dec1).not.toBe(dec2);
expect(dec1.descriptor).toEqual(dec2.descriptor);
expect(dec1.descriptor).not.toBe(dec2.descriptor);
expect(dec1.initializer).toBe(dec2.initializer);
"#
);
// transformation_export_default_named
test!(
syntax(false),
|_| transformation(),
transformation_export_default_named,
r#"
export default @dec() class Foo {}
"#,
r#"
let Foo = _decorate([dec()], function (_initialize) {
class Foo {
constructor() {
_initialize(this);
}
}
return {
F: Foo,
d: []
};
});
export { Foo as default };
"#
);
// element_descriptors_original_own_field_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_original_own_field_exec,
r#"
var el = null;
var val = {};
class A {
@(_ => el = _)
foo = val;
}
expect(el).toEqual(Object.defineProperty({
kind: "field",
key: "foo",
placement: "own",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
},
initializer: expect.any(Function),
}, Symbol.toStringTag, { value: "Descriptor" }));
expect(el.initializer()).toBe(val);
"#
);
// transformation
// ordering_decorators_exec
test_exec!(
syntax(false),
|_| tr(),
ordering_decorators_exec,
r#"
var log = [];
function push(x) { log.push(x); return x; }
function logDecoratorRun(a, b) {
push(a);
return function (el) { push(b); return el; };
}
@logDecoratorRun(0, 23)
@logDecoratorRun(1, 22)
class A {
@logDecoratorRun(2, 15)
@logDecoratorRun(3, 14)
[push(4)] = "4";
@logDecoratorRun(5, 17)
@logDecoratorRun(6, 16)
static [push(7)]() {}
@logDecoratorRun(8, 19)
@logDecoratorRun(9, 18)
static [push(10)] = "10";
@logDecoratorRun(11, 21)
@logDecoratorRun(12, 20)
[push(13)]() {}
}
var numsFrom0to23 = Array.from({ length: 24 }, (_, i) => i);
expect(log).toEqual(numsFrom0to23);
"#
);
// transformation_async_generator_method
// element_descriptors_default_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_default_exec,
r#"
function decorate(el) {
el.descriptor.value = 2;
}
var Foo;
expect(() => {
Foo = @(() => void 0) class Foo {
@decorate
bar() {}
}
}).not.toThrow();
expect(Foo.prototype.bar).toBe(2);
"#
);
// element_descriptors_original_prototype_method_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_original_prototype_method_exec,
r#"
var el = null;
class A {
@(_ => el = _)
foo() {}
}
expect(el).toEqual(Object.defineProperty({
kind: "method",
key: "foo",
placement: "prototype",
descriptor: {
enumerable: false,
configurable: true,
writable: true,
value: A.prototype.foo,
},
}, Symbol.toStringTag, { value: "Descriptor" }));
"#
);
// misc_method_name_exec
test_exec!(
syntax(false),
|_| tr(),
misc_method_name_exec,
r#"
function decorator() {}
@decorator
class Foo {
method() {}
}
expect(Foo.prototype.method.name).toBe("method");
"#
);
// transformation_strict_directive
test!(
ignore,
syntax(false),
|_| transformation(),
transformation_strict_directive,
r#"
(() => {
@dec
class Foo {
method() {}
}
});
(() => {
@dec
class Foo {
method() {}
}
});
"#,
r#"
() => {
let Foo = _decorate([dec], function (_initialize) {
class Foo {
constructor() {
_initialize(this);
}
}
return {
F: Foo,
d: [{
kind: "method",
key: "method",
value: function method() {}
}]
};
});
};
() => {
let Foo = _decorate([dec], function (_initialize2) {
class Foo {
constructor() {
_initialize2(this);
}
}
return {
F: Foo,
d: [{
kind: "method",
key: "method",
value: function method() {}
}]
};
});
};
"#
);
// element_descriptors_created_static_method_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_created_static_method_exec,
r#"
function pushElement(e) {
return function (c) { c.elements.push(e); return c };
}
function method() {}
@pushElement({
kind: "method",
placement: "static",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: method,
}
})
class A {}
expect(A.prototype).not.toHaveProperty("foo");
expect(new A()).not.toHaveProperty("foo");
expect(Object.getOwnPropertyDescriptor(A, "foo")).toEqual({
enumerable: true,
configurable: true,
writable: true,
value: method,
});
"#
);
// misc_method_name_not_shadow_exec
test_exec!(
syntax(false),
|_| tr(),
misc_method_name_not_shadow_exec,
r#"
function decorator() {}
var method = 1;
@decorator
class Foo {
method() {
return method;
}
}
expect(new Foo().method()).toBe(1);
expect(Foo.prototype.method.name).toBe("method");
"#
);
// transformation_class_decorators_yield_await
// duplicated_keys_original_method_overwritten_second_decorated_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_original_method_overwritten_second_decorated_exec,
r#"
expect(() => {
class A {
@(el => el)
method() {
return 1;
}
method() {
return 2;
}
}
}).toThrow(ReferenceError);
"#
);
// duplicated_keys_get_set_both_decorated_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_get_set_both_decorated_exec,
r#"
function dec(el) { return el }
expect(() => {
class A {
@dec
get foo() {}
@dec
set foo(x) {}
}
}).toThrow(ReferenceError);
"#
);
// duplicated_keys_original_method_overwritten_first_decorated_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_original_method_overwritten_first_decorated_exec,
r#"
expect(() => {
class A {
method() {
return 1;
}
@(el => el)
method() {
return 2;
}
}
}).toThrow(ReferenceError);
"#
);
// element_descriptors_created_prototype_field_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_created_prototype_field_exec,
r#"
function pushElement(e) {
return function (c) { c.elements.push(e); return c };
}
var value = {};
@pushElement({
kind: "field",
placement: "prototype",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
},
initializer() {
return value;
}
})
class A {}
expect(A).not.toHaveProperty("foo");
expect(Object.getOwnPropertyDescriptor(A.prototype, "foo")).toEqual({
enumerable: true,
configurable: true,
writable: true,
value: value,
});
"#
);
// transformation_extends
test!(
syntax(false),
|_| transformation(),
transformation_extends,
r#"
@dec class A extends B {}
"#,
r#"
let A = _decorate([dec], function (_initialize, _B) {
class A extends _B {
constructor(...args) {
super(...args);
_initialize(this);
}
}
return {
F: A,
d: []
};
}, B);
"#
);
// finishers
// transformation_extends_await
test!(
syntax(false),
|_| transformation(),
transformation_extends_await,
r#"
async function g() {
@dec class A extends (await B) {}
}
"#,
r#"
async function g() {
let A = _decorate([dec], function (_initialize, _super) {
class A extends _super {
constructor(...args) {
super(...args);
_initialize(this);
}
}
return {
F: A,
d: []
};
}, await B);
}
"#
);
// transformation_extends_yield
test!(
syntax(false),
|_| transformation(),
transformation_extends_yield,
r#"
function* g() {
@dec class A extends (yield B) {}
}
"#,
r#"
function* g() {
let A = _decorate([dec], function (_initialize, _super) {
class A extends _super {
constructor(...args) {
super(...args);
_initialize(this);
}
}
return {
F: A,
d: []
};
}, (yield B));
}
"#
);
// element_descriptors_created_static_field_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_created_static_field_exec,
r#"
function pushElement(e) {
return function (c) { c.elements.push(e); return c };
}
var value = {};
@pushElement({
kind: "field",
placement: "static",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
},
initializer() {
return value;
}
})
class A {}
expect(A.prototype).not.toHaveProperty("foo");
expect(new A()).not.toHaveProperty("foo");
expect(Object.getOwnPropertyDescriptor(A, "foo")).toEqual({
enumerable: true,
configurable: true,
writable: true,
value: value,
});
"#
);
// element_descriptors_created_own_field_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_created_own_field_exec,
r#"
function pushElement(e) {
return function (c) { c.elements.push(e); return c };
}
var value = {};
@pushElement({
kind: "field",
placement: "own",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
},
initializer() {
return value;
}
})
class A {}
expect(A).not.toHaveProperty("foo");
expect(A.prototype).not.toHaveProperty("foo");
expect(Object.getOwnPropertyDescriptor(new A(), "foo")).toEqual({
enumerable: true,
configurable: true,
writable: true,
value: value,
});
"#
);
// element_descriptors_not_reused_method_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_not_reused_method_exec,
r#"
var dec1, dec2;
class A {
@(_ => dec1 = _)
@(_ => dec2 = _)
fn() {}
}
expect(dec1).toEqual(dec2);
expect(dec1).not.toBe(dec2);
expect(dec1.descriptor).toEqual(dec2.descriptor);
expect(dec1.descriptor).not.toBe(dec2.descriptor);
expect(dec1.descriptor.value).toBe(dec2.descriptor.value);
"#
);
// element_descriptors_not_reused_class_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_not_reused_class_exec,
r#"
var dec1, dec2;
@(_ => dec1 = _)
@(_ => dec2 = _)
class A {}
expect(dec1).toEqual(dec2);
expect(dec1).not.toBe(dec2);
"#
);
// duplicated_keys_computed_keys_same_ast_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_computed_keys_same_ast_exec,
r#"
var i = 0;
function getKey() {
return (i++).toString();
}
var desc;
@(_ => desc = _)
class Foo {
[getKey()]() {
return 1;
}
[getKey()]() {
return 2;
}
}
expect(desc.elements).toHaveLength(2);
expect(desc.elements[0].key).toBe("0");
expect(desc.elements[0].descriptor.value()).toBe(1);
expect(desc.elements[1].key).toBe("1");
expect(desc.elements[1].descriptor.value()).toBe(2);
expect(i).toBe(2);
"#
);
// transformation_initialize_after_super_bug_8931
test!(
syntax(false),
|_| transformation(),
transformation_initialize_after_super_bug_8931,
r#"
@dec
class B extends A {
constructor() {
super();
[];
}
}
"#,
r#"
let B = _decorate([dec], function (_initialize, _A) {
class B extends _A {
constructor() {
super();
_initialize(this);
[];
}
}
return {
F: B,
d: []
};
}, A);
"#
);
// duplicated_keys
// ordering_static_field_initializers_after_methods_exec
test_exec!(
// Babel 7.3.0 fails
ignore,
syntax(false),
|_| tr(),
ordering_static_field_initializers_after_methods_exec,
r#"
var counter = 0;
@(x => x)
class A {
static foo = (() => {
counter++;
expect(typeof this.method).toBe("function");
expect(this.foo).toBeUndefined();
expect(this.bar).toBeUndefined();
return "foo";
})();
static method() {}
static bar = (() => {
counter++;
expect(typeof this.method).toBe("function");
expect(this.foo).toBe("foo");
expect(this.bar).toBeUndefined();
})();
}
expect(counter).toBe(2);
"#
);
// element_descriptors_original_static_method_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_original_static_method_exec,
r#"
var el = null;
class A {
@(_ => el = _)
static foo() {}
}
expect(el).toEqual(Object.defineProperty({
kind: "method",
key: "foo",
placement: "static",
descriptor: {
enumerable: false,
configurable: true,
writable: true,
value: A.foo,
},
}, Symbol.toStringTag, { value: "Descriptor" }));
"#
);
// duplicated_keys_extras_duplicated_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_extras_duplicated_exec,
r#"
function decorate(el) {
el.extras = [{
kind: "method",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: function() {},
}
}, {
kind: "method",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: function() {},
}
}];
return el;
}
expect(() => {
class A {
@decorate
method() {}
}
}).toThrow(TypeError);
"#
);
// duplicated_keys_extras_same_as_return_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_extras_same_as_return_exec,
r#"
function decorate(el) {
return {
kind: "method",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: function() {},
},
extras: [{
kind: "method",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: function() {},
}
}]
};
}
expect(() => {
class A {
@decorate
method() {}
}
}).toThrow(TypeError);
"#
);
// finishers_class_as_parameter_exec
test_exec!(
syntax(false),
|_| tr(),
finishers_class_as_parameter_exec,
r#"
var C;
function decorator(el) {
return Object.assign(el, {
finisher(Class) {
C = Class;
},
});
}
class A {
@decorator
foo() {}
}
expect(C).toBe(A);
"#
);
// duplicated_keys_moved_and_created_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_moved_and_created_exec,
r#"
var value1, value2 = {};
function makeStatic(el) {
el.placement = "static";
return el;
}
function defineBar(el) {
el.extras = [{
key: "bar",
kind: "method",
placement: "prototype",
descriptor: {
value: value2,
},
}];
return el;
}
function storeValue(el) {
value1 = el.descriptor.value;
return el;
}
class Foo {
@defineBar
@makeStatic
@storeValue
bar() {}
}
expect(Foo.bar).toBe(value1);
expect(Foo.prototype.bar).toBe(value2);
"#
);
// transformation_expression
test!(
syntax(false),
|_| transformation(),
transformation_expression,
r#"
(@dec() class {});
"#,
r#"
_decorate([dec()], function (_initialize) {
class _class {
constructor() {
_initialize(this);
}
}
return {
F: _class,
d: []
};
});
"#
);
// duplicated_keys_original_method_prototype_and_static_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_original_method_prototype_and_static_exec,
r#"
var el;
@(_ => el = _)
class A {
method() {
return 1;
}
static method() {
return 2;
}
}
expect(el.elements).toHaveLength(2);
expect(A.prototype.method()).toBe(1);
expect(A.method()).toBe(2);
"#
);
// element_descriptors
// duplicated_keys_computed_keys_same_ast
test!(
syntax(false),
|_| tr(),
duplicated_keys_computed_keys_same_ast,
r#"
@(_ => desc = _)
class Foo {
[getKey()]() {
return 1;
}
[getKey()]() {
return 2;
}
}
"#,
r#"
let Foo = _decorate([_ => desc = _], function (_initialize) {
class Foo {
constructor() {
_initialize(this);
}
}
return {
F: Foo,
d: [{
kind: "method",
key: getKey(),
value: function () {
return 1;
}
}, {
kind: "method",
key: getKey(),
value: function () {
return 2;
}
}]
};
});
"#
);
// element_descriptors_created_prototype_method_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_created_prototype_method_exec,
r#"
function pushElement(e) {
return function (c) { c.elements.push(e); return c };
}
function method() {}
@pushElement({
kind: "method",
placement: "prototype",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: method,
}
})
class A {}
expect(A).not.toHaveProperty("foo");
expect(Object.getOwnPropertyDescriptor(A.prototype, "foo")).toEqual({
enumerable: true,
configurable: true,
writable: true,
value: method,
});
"#
);
// duplicated_keys_create_existing_element_from_method_decorator_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_create_existing_element_from_method_decorator_exec,
r#"
function decorate() {
return {
kind: "method",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: function() {},
}
};
}
expect(() => {
class A {
@decorate
bar() {}
foo() {}
}
}).toThrow(TypeError);
"#
);
// element_descriptors_original_static_field_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_original_static_field_exec,
r#"
var el = null;
var val = { foo: 2 };
class A {
@(_ => el = _)
static foo = val;
}
expect(el).toEqual(Object.defineProperty({
kind: "field",
key: "foo",
placement: "static",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
},
initializer: expect.any(Function),
}, Symbol.toStringTag, { value: "Descriptor" }));
expect(el.initializer()).toBe(val);
"#
);
// duplicated_keys_coalesce_get_set_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_coalesce_get_set_exec,
r#"
var el, el1;
@(_ => el = _)
class A {
@(_ => el1 = _)
get foo() { return 1; }
set foo(x) { return 2; }
}
expect(el.elements).toHaveLength(1);
expect(el1).toEqual(expect.objectContaining({
descriptor: expect.objectContaining({
get: expect.any(Function),
set: expect.any(Function)
})
}));
var desc = Object.getOwnPropertyDescriptor(A.prototype, "foo");
expect(desc.get()).toBe(1);
expect(desc.set()).toBe(2);
"#
);
// misc
// transformation_extends_exec
test_exec!(
syntax(false),
|_| tr(),
transformation_extends_exec,
r#"
class B {}
@(_ => _)
class A extends B {}
expect(new A).toBeInstanceOf(A);
expect(new A).toBeInstanceOf(B);
"#
);
// duplicated_keys_create_existing_element_from_class_decorator_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_create_existing_element_from_class_decorator_exec,
r#"
function pushElement(e) {
return function (c) { c.elements.push(e); return c };
}
expect(() => {
@pushElement({
kind: "method",
key: "foo",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
value: function() {},
}
})
class A {
foo() {}
}
}).toThrow(TypeError);
"#
);
// duplicated_keys_computed_keys_same_value_exec
test_exec!(
syntax(false),
|_| tr(),
duplicated_keys_computed_keys_same_value_exec,
r#"
var i = 0;
var j = 0;
function getKeyI() {
return (i++).toString();
}
function getKeyJ() {
return (j++).toString();
}
var desc;
@(_ => desc = _)
class Foo {
[getKeyI()]() {
return 1;
}
[getKeyJ()]() {
return 2;
}
}
expect(desc.elements).toHaveLength(1);
expect(desc.elements[0].key).toBe("0");
expect(desc.elements[0].descriptor.value()).toBe(2);
expect(i).toBe(1);
expect(j).toBe(1);
"#
);
// element_descriptors_original_own_field_without_initiailzer_exec
test_exec!(
syntax(false),
|_| tr(),
element_descriptors_original_own_field_without_initiailzer_exec,
r#"
var el = null;
class A {
@(_ => el = _)
foo;
}
expect(el).toEqual(Object.defineProperty({
kind: "field",
key: "foo",
placement: "own",
descriptor: {
enumerable: true,
configurable: true,
writable: true,
},
initializer: undefined,
}, Symbol.toStringTag, { value: "Descriptor" }));
"#
);
// legacy_class_constructors_return_new_constructor
test_exec!(
syntax(true),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_constructors_return_new_constructor_exec,
r#"
function dec(cls){
return class Child extends cls {
child(){}
};
}
@dec
class Parent {
parent(){}
}
expect(typeof Parent.prototype.parent).toBe("function");
expect(typeof Parent.prototype.child).toBe("function");
"#
);
// legacy_regression_10264
test!(
syntax(true),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
simple_strip()
),
legacy_regression_10264,
r#"
function myDecorator(decoratee) {}
@myDecorator
export default class {}
"#,
r#"
var _class;
function myDecorator(decoratee) {
}
let _class1 = _class = myDecorator((_class = class {
}) || _class) || _class;
export { _class1 as default }
"#
);
//// legacy_regression_7030
//test!(
// syntax(false),
// |_| tr(r#"{
// "presets": ["env"]
//}
//"#),
// legacy_regression_7030,
// r#"
//function generateAsyncAction(type) {
// type = type.toUpperCase()
// const request = createAction(type+'_REQUEST',
// undefined, requestMetaCreator
// )
// request.request = request // crazy
// request.success = createAction(type+'_SUCCESS', undefined, metaCreator)
// request.error = createAction(type+'_ERROR', undefined, metaCreator)
// request.cancel = createAction(type+'_CANCEL', undefined, metaCreator)
// request.progress = createAction(type+'_PROGRESS', undefined, metaCreator)
// request.process = createAction(type+'_PROCESS', undefined, metaCreator)
//
// return request
//}
//
//class A extends B {
// constructor(timestamp) {
// super()
// this.timestamp = timestamp
// this.moment = moment(timestamp)
// }
//}
//
//"#,
// r#"
//function _typeof(obj) { if (typeof Symbol === "function" && typeof
// Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return
// typeof obj; }; } else { _typeof = function _typeof(obj) { return obj &&
// typeof Symbol === "function" && obj.constructor === Symbol && obj !==
// Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
//
//function _classCallCheck(instance, Constructor) { if (!(instance instanceof
// Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
//
//function _possibleConstructorReturn(self, call) { if (call && (_typeof(call)
// === "object" || typeof call === "function")) { return call; } return
// _assertThisInitialized(self); }
//
//function _assertThisInitialized(self) { if (self === void 0) { throw new
// ReferenceError("this hasn't been initialised - super() hasn't been called");
// } return self; }
//
//function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ?
// Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ ||
// Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
//
//function _inherits(subClass, superClass) { if (typeof superClass !==
// "function" && superClass !== null) { throw new TypeError("Super expression
// must either be null or a function"); } subClass.prototype =
// Object.create(superClass && superClass.prototype, { constructor: { value:
// subClass, writable: true, configurable: true } }); if (superClass)
// _setPrototypeOf(subClass, superClass); }
//
//function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ||
// function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return
// _setPrototypeOf(o, p); }
//
//function generateAsyncAction(type) {
// type = type.toUpperCase();
// var request = createAction(type + '_REQUEST', undefined,
// requestMetaCreator); request.request = request; // crazy
//
// request.success = createAction(type + '_SUCCESS', undefined, metaCreator);
// request.error = createAction(type + '_ERROR', undefined, metaCreator);
// request.cancel = createAction(type + '_CANCEL', undefined, metaCreator);
// request.progress = createAction(type + '_PROGRESS', undefined, metaCreator);
// request.process = createAction(type + '_PROCESS', undefined, metaCreator);
// return request;
//}
//
//var A =
// /*#__PURE__*/
//function (_B) {
// "use strict";
//
// _inherits(A, _B);
//
// function A(timestamp) {
// var _this;
//
// _classCallCheck(this, A);
//
// _this = _possibleConstructorReturn(this, _getPrototypeOf(A).call(this));
// _this.timestamp = timestamp;
// _this.moment = moment(timestamp);
// return _this;
// }
//
// return A;
//}(B);
//
//"#
//);
//// legacy_class_static_methods_numeric_props
//test_exec!(
// syntax(false),
// |_| tr(r#"{
// "presets": ["env"],
// "plugins": [
// ["proposal-decorators", { "legacy": true }],
// [class_properties(class_properties::Config { loose: false }), { "loose":
// true }] ]
//}
//"#),
// legacy_class_static_methods_numeric_props_exec,
// r#"
//function dec(target, name, descriptor){
// expect(target).toBeTruthy();
// expect(name).toBe(4);
// expect(typeof descriptor).toBe("object");
//}
//
//class Example {
// @dec
// static 4() {}
//}
//
//"#
//);
//// legacy_class_prototype_properties_mutate_descriptor
//test_exec!(
// syntax(false),
// |_| tr(r#"{
// "presets": ["env"],
// "plugins": [
// ["proposal-decorators", { "legacy": true }],
// [class_properties(class_properties::Config { loose: false }), { "loose":
// true }] ]
//}
//"#),
// legacy_class_prototype_properties_mutate_descriptor_exec,
// r#"
//function dec(target, name, descriptor) {
// expect(target).toBeTruthy();
// expect(typeof name).toBe("string");
// expect(typeof descriptor).toBe("object");
//
// target.decoratedProps = (target.decoratedProps || []).concat([name]);
//
// let initializer = descriptor.initializer;
// Object.assign(descriptor, {
// enumerable: name.indexOf('enum') !== -1,
// configurable: name.indexOf('conf') !== -1,
// writable: name.indexOf('write') !== -1,
// initializer: function(...args){
// return '__' + initializer.apply(this, args) + '__';
// },
// });
//}
//
//function plainDec(target, name, descriptor) {
// expect(target).toBeTruthy();
// expect(typeof name).toBe("string");
// expect(typeof descriptor).toBe("object");
//
// target.decoratedProps = (target.decoratedProps || []).concat([name]);
//
// return descriptor;
//}
//
//class Example {
// @dec
// enumconfwrite = 1;
//
// @dec
// enumconf = 2;
//
// @dec
// enumwrite = 3;
//
// @dec
// enum = 4;
//
// @dec
// confwrite = 5;
//
// @dec
// conf = 6;
//
// @dec
// write = 7;
//
// @dec
// _ = 8;
//
// @plainDec
// plain = 9;
//}
//
//const inst = new Example();
//
//expect(Example.prototype).toHaveProperty("decoratedProps");
//expect(inst.decoratedProps).toEqual([
// "enumconfwrite",
// "enumconf",
// "enumwrite",
// "enum",
// "confwrite",
// "conf",
// "write",
// "_",
// "plain",
//]);
//
//const descs = Object.getOwnPropertyDescriptors(inst);
//
//expect(descs.enumconfwrite.enumerable).toBeTruthy();
//expect(descs.enumconfwrite.writable).toBeTruthy();
//expect(descs.enumconfwrite.configurable).toBeTruthy();
//expect(inst.enumconfwrite).toBe("__1__");
//
//expect(descs.enumconf.enumerable).toBeTruthy();
//expect(descs.enumconf.writable).toBe(false);
//expect(descs.enumconf.configurable).toBeTruthy();
//expect(inst.enumconf).toBe("__2__");
//
//expect(descs.enumwrite.enumerable).toBeTruthy();
//expect(descs.enumwrite.writable).toBeTruthy();
//expect(descs.enumwrite.configurable).toBe(false);
//expect(inst.enumwrite).toBe("__3__");
//
//expect(descs.enum.enumerable).toBeTruthy();
//expect(descs.enum.writable).toBe(false);
//expect(descs.enum.configurable).toBe(false);
//expect(inst.enum).toBe("__4__");
//
//expect(descs.confwrite.enumerable).toBe(false);
//expect(descs.confwrite.writable).toBeTruthy();
//expect(descs.confwrite.configurable).toBeTruthy();
//expect(inst.confwrite).toBe("__5__");
//
//expect(descs.conf.enumerable).toBe(false);
//expect(descs.conf.writable).toBe(false);
//expect(descs.conf.configurable).toBeTruthy();
//expect(inst.conf).toBe("__6__");
//
//expect(descs.write.enumerable).toBe(false);
//expect(descs.write.writable).toBeTruthy();
//expect(descs.write.configurable).toBe(false);
//expect(inst.write).toBe("__7__");
//
//expect(descs._.enumerable).toBe(false);
//expect(descs._.writable).toBe(false);
//expect(descs._.configurable).toBe(false);
//expect(inst._).toBe("__8__");
//
//expect(descs.plain.enumerable).toBeTruthy();
//expect(descs.plain.writable).toBeTruthy();
//expect(descs.plain.configurable).toBeTruthy();
//expect(inst.plain).toBe(9);
//
//"#
//);
//// legacy_object_properties_mutate_descriptor
//test_exec!(
// syntax(false),
// |_| tr(r#"{
// "presets": ["env"],
// "plugins": [
// ["proposal-decorators", { "legacy": true }],
// [class_properties(class_properties::Config { loose: false }), { "loose":
// true }] ]
//}
//"#),
// legacy_object_properties_mutate_descriptor_exec,
// r#"
//function dec(target, name, descriptor) {
// expect(target).toBeTruthy();
// expect(typeof name).toBe("string");
// expect(typeof descriptor).toBe("object");
//
// target.decoratedProps = (target.decoratedProps || []).concat([name]);
//
// let initializer = descriptor.initializer;
// Object.assign(descriptor, {
// enumerable: name.indexOf("enum") !== -1,
// configurable: name.indexOf("conf") !== -1,
// writable: name.indexOf("write") !== -1,
// initializer: function(...args){
// return '__' + initializer.apply(this, args) + '__';
// },
// });
//}
//
//const inst = {
// @dec
// enumconfwrite: 1,
//
// @dec
// enumconf: 2,
//
// @dec
// enumwrite: 3,
//
// @dec
// enum: 4,
//
// @dec
// confwrite: 5,
//
// @dec
// conf: 6,
//
// @dec
// write: 7,
//
// @dec
// _: 8,
//};
//
//
//expect(inst).toHaveProperty("decoratedProps");
//expect(inst.decoratedProps).toEqual([
// "enumconfwrite",
// "enumconf",
// "enumwrite",
// "enum",
// "confwrite",
// "conf",
// "write",
// "_",
//]);
//
//const descs = Object.getOwnPropertyDescriptors(inst);
//
//expect(descs.enumconfwrite.enumerable).toBeTruthy();
//expect(descs.enumconfwrite.writable).toBeTruthy();
//expect(descs.enumconfwrite.configurable).toBeTruthy();
//expect(inst.enumconfwrite).toBe("__1__");
//
//expect(descs.enumconf.enumerable).toBeTruthy();
//expect(descs.enumconf.writable).toBe(false);
//expect(descs.enumconf.configurable).toBeTruthy();
//expect(inst.enumconf).toBe("__2__");
//
//expect(descs.enumwrite.enumerable).toBeTruthy();
//expect(descs.enumwrite.writable).toBeTruthy();
//expect(descs.enumwrite.configurable).toBe(false);
//expect(inst.enumwrite).toBe("__3__");
//
//expect(descs.enum.enumerable).toBeTruthy();
//expect(descs.enum.writable).toBe(false);
//expect(descs.enum.configurable).toBe(false);
//expect(inst.enum).toBe("__4__");
//
//expect(descs.confwrite.enumerable).toBe(false);
//expect(descs.confwrite.writable).toBeTruthy();
//expect(descs.confwrite.configurable).toBeTruthy();
//expect(inst.confwrite).toBe("__5__");
//
//expect(descs.conf.enumerable).toBe(false);
//expect(descs.conf.writable).toBe(false);
//expect(descs.conf.configurable).toBeTruthy();
//expect(inst.conf).toBe("__6__");
//
//expect(descs.write.enumerable).toBe(false);
//expect(descs.write.writable).toBeTruthy();
//expect(descs.write.configurable).toBe(false);
//expect(inst.write).toBe("__7__");
//
//expect(descs._.enumerable).toBe(false);
//expect(descs._.writable).toBe(false);
//expect(descs._.configurable).toBe(false);
//expect(inst._).toBe("__8__");
//
//"#
//);
// legacy_decl_to_expression_class_decorators
test!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
legacy_decl_to_expression_class_decorators,
r#"
export default @dec class A {}
@dec class B {}
"#,
r#"
var _class, _class1;
export default _class = dec((_class = class A {
}) || _class) || _class;
let B = _class1 = dec((_class1 = class B {
}) || _class1) || _class1;
"#
);
// legacy_class_prototype_methods_numeric_props
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_prototype_methods_numeric_props_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(name).toBe(4);
expect(typeof descriptor).toBe("object");
}
class Example {
@dec
4() {};
}
"#
);
// legacy_class_static_properties_mutate_descriptor
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_static_properties_mutate_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let initializer = descriptor.initializer;
Object.assign(descriptor, {
enumerable: name.indexOf("enum") !== -1,
configurable: name.indexOf("conf") !== -1,
writable: name.indexOf("write") !== -1,
initializer: function(...args){
return '__' + initializer.apply(this, args) + '__';
},
});
}
class Example {
@dec
static enumconfwrite = 1;
@dec
static enumconf = 2;
@dec
static enumwrite = 3;
@dec
static enum = 4;
@dec
static confwrite = 5;
@dec
static conf = 6;
@dec
static write = 7;
@dec
static _ = 8;
}
const inst = new Example();
expect(Example).toHaveProperty("decoratedProps");
expect(Example.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(Example);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(Example.enumconfwrite).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(Example.enumconf).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(Example.enumwrite).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(Example.enum).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(Example.confwrite).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(Example.conf).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(Example.write).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(Example._).toBe("__8__");
"#
);
// legacy_class_static_methods_string_props
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_static_methods_string_props_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(name).toBe("str");
expect(typeof descriptor).toBe("object");
}
class Example {
@dec
static "str"() {};
}
"#
);
// legacy_class_prototype_properties_string_literal_properties
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_prototype_properties_string_literal_properties_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
return descriptor;
}
class Example {
@dec "a-prop";
}
let inst = new Example();
expect(Example.prototype).toHaveProperty("decoratedProps");
expect(inst.decoratedProps).toEqual([
"a-prop"
]);
expect(inst).toHaveProperty("a-prop");
expect(inst["a-prop"]).toBeUndefined();
// const descs = Object.getOwnPropertyDescriptors(inst);
// expect(descs["a-prop"].enumerable).toBeTruthy();
// expect(descs["a-prop"].writable).toBeTruthy();
// expect(descs["a-prop"].configurable).toBeTruthy();
"#
);
// legacy_class_prototype_methods_mutate_descriptor
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_prototype_methods_mutate_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let value = descriptor.value;
Object.assign(descriptor, {
enumerable: name.indexOf("enum") !== -1,
configurable: name.indexOf("conf") !== -1,
writable: name.indexOf("write") !== -1,
value: function(...args) {
return "__" + value.apply(this, args) + "__";
},
});
}
class Example {
@dec
enumconfwrite(){
return 1;
}
@dec
enumconf(){
return 2;
}
@dec
enumwrite(){
return 3;
}
@dec
enum(){
return 4;
}
@dec
confwrite(){
return 5;
}
@dec
conf(){
return 6;
}
@dec
write(){
return 7;
}
@dec
_(){
return 8;
}
}
expect(Example.prototype).toHaveProperty('decoratedProps');
expect(Example.prototype.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const inst = new Example();
const descs = Object.getOwnPropertyDescriptors(Example.prototype);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(inst.enumconfwrite()).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(inst.enumconf()).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(inst.enumwrite()).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(inst.enum()).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(inst.confwrite()).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(inst.conf()).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(inst.write()).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(inst._()).toBe("__8__");
"#
);
// legacy_object_properties_numeric_props
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_properties_numeric_props_exec,
r#"
function dec(target, name, descriptor){
expect(target).toBeTruthy();
expect(name).toBe(4);
expect(typeof descriptor).toBe("object");
}
const inst = {
@dec
4: 1
};
"#
);
// legacy_decl_to_expression_method_decorators
test!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
legacy_decl_to_expression_method_decorators,
r#"
export default class A {
@dec foo() {}
}
class B {
@dec foo() {}
}
"#,
r#"
var _class, _class1;
let A = ((_class = class A{
foo() {
}
}) || _class, _applyDecoratedDescriptor(_class.prototype, 'foo', [dec], Object.getOwnPropertyDescriptor(_class.prototype, 'foo'), _class.prototype), _class);
let B = ((_class1 = class B{
foo() {
}
}) || _class1, _applyDecoratedDescriptor(_class1.prototype, 'foo', [dec], Object.getOwnPropertyDescriptor(_class1.prototype, 'foo'), _class1.prototype), _class1);
export { A as default }
"#
);
// legacy_class_prototype_properties_return_descriptor
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_prototype_properties_return_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let initializer = descriptor.initializer;
return {
enumerable: name.indexOf('enum') !== -1,
configurable: name.indexOf('conf') !== -1,
writable: name.indexOf('write') !== -1,
initializer: function(...args){
return '__' + initializer.apply(this, args) + '__';
},
};
}
class Example {
@dec
enumconfwrite = 1;
@dec
enumconf = 2;
@dec
enumwrite = 3;
@dec
enum = 4;
@dec
confwrite = 5;
@dec
conf = 6;
@dec
write = 7;
@dec
_ = 8;
}
const inst = new Example();
expect(Example.prototype).toHaveProperty("decoratedProps");
expect(inst.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(inst);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(inst.enumconfwrite).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(inst.enumconf).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(inst.enumwrite).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(inst.enum).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(inst.confwrite).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(inst.conf).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(inst.write).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(inst._).toBe("__8__");
"#
);
// legacy_object_properties_string_props
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_properties_string_props_exec,
r#"
function dec(target, name, descriptor){
expect(target).toBeTruthy();
expect(name).toBe("str");
expect(typeof descriptor).toBe("object");
}
const inst = {
@dec
"str": 1
};
"#
);
// legacy_object_properties_return_descriptor
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_properties_return_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let initializer = descriptor.initializer;
return {
enumerable: name.indexOf('enum') !== -1,
configurable: name.indexOf('conf') !== -1,
writable: name.indexOf('write') !== -1,
initializer: function(...args){
return '__' + initializer.apply(this, args) + '__';
},
};
}
const inst = {
@dec
enumconfwrite: 1,
@dec
enumconf: 2,
@dec
enumwrite: 3,
@dec
enum: 4,
@dec
confwrite: 5,
@dec
conf: 6,
@dec
write: 7,
@dec
_: 8,
};
expect(inst).toHaveProperty("decoratedProps");
expect(inst.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(inst);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(inst.enumconfwrite).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(inst.enumconf).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(inst.enumwrite).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(inst.enum).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(inst.confwrite).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(inst.conf).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(inst.write).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(inst._).toBe("__8__");
"#
);
// legacy_class_prototype_methods_string_props
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_prototype_methods_string_props_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(name).toBe("str");
expect(typeof descriptor).toBe("object");
}
class Example {
@dec
"str"() {};
}
"#
);
// legacy_regression_8041
test!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_regression_8041,
r#"
export default class {
@foo
bar() {}
}
"#,
r#"
var _class;
let _class2 = ((_class = class _class1 {
bar() {
}
}) || _class, _applyDecoratedDescriptor(_class.prototype, "bar", [
foo
], Object.getOwnPropertyDescriptor(_class.prototype, "bar"), _class.prototype), _class);
export { _class2 as default };
"#
);
// legacy_class_prototype_methods_return_descriptor
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_prototype_methods_return_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let value = descriptor.value;
return {
enumerable: name.indexOf('enum') !== -1,
configurable: name.indexOf('conf') !== -1,
writable: name.indexOf('write') !== -1,
value: function(...args){
return '__' + value.apply(this, args) + '__';
},
};
}
class Example {
@dec
enumconfwrite() {
return 1;
}
@dec
enumconf() {
return 2;
}
@dec
enumwrite() {
return 3;
}
@dec
enum() {
return 4;
}
@dec
confwrite() {
return 5;
}
@dec
conf() {
return 6;
}
@dec
write() {
return 7;
}
@dec
_() {
return 8;
}
}
expect(Example.prototype).toHaveProperty('decoratedProps');
expect(Example.prototype.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const inst = new Example();
const descs = Object.getOwnPropertyDescriptors(Example.prototype);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(inst.enumconfwrite()).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(inst.enumconf()).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(inst.enumwrite()).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(inst.enum()).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(inst.confwrite()).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(inst.conf()).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(inst.write()).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(inst._()).toBe("__8__");
"#
);
// legacy_object_ordering_reverse_order
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_ordering_reverse_order_exec,
r#"
const calls = [];
function dec(id){
return function(){
calls.push(id);
};
}
const obj = {
@dec(2)
@dec(1)
method1(){},
@dec(4)
@dec(3)
prop1: 1,
@dec(6)
@dec(5)
method2(){},
@dec(8)
@dec(7)
prop2: 2,
}
expect(calls).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
"#
);
// legacy_object_methods_numeric_props
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_methods_numeric_props_exec,
r#"
function dec(target, name, descriptor){
expect(target).toBeTruthy();
expect(name).toBe(4);
expect(typeof descriptor).toBe("object");
}
const inst = {
@dec
4(){
}
};
"#
);
// legacy_class_static_properties_return_descriptor
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_static_properties_return_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let initializer = descriptor.initializer;
return {
enumerable: name.indexOf('enum') !== -1,
configurable: name.indexOf('conf') !== -1,
writable: name.indexOf('write') !== -1,
initializer: function(...args){
return '__' + initializer.apply(this, args) + '__';
},
};
}
class Example {
@dec
static enumconfwrite = 1;
@dec
static enumconf = 2;
@dec
static enumwrite = 3;
@dec
static enum = 4;
@dec
static confwrite = 5;
@dec
static conf = 6;
@dec
static write = 7;
@dec
static _ = 8;
}
const inst = new Example();
expect(Example).toHaveProperty("decoratedProps");
expect(Example.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(Example);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(Example.enumconfwrite).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(Example.enumconf).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(Example.enumwrite).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(Example.enum).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(Example.confwrite).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable);
expect(Example.conf).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(Example.write).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(Example._).toBe("__8__");
"#
);
// legacy_class_export_default
test_exec!(
// We wrap exec tests in a function like it('should work', function(){
// // .. code
// }), but it prevents swc_ecma_parser from parsing the code
// below correctly.
ignore,
syntax(true),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_export_default_exec,
r#"
const calls = [];
function foo(target) {
calls.push(target.name);
}
@foo
export default class Foo {
bar() {
class Baz {}
}
}
expect(calls).toEqual(["Foo"]);
"#
);
// legacy_class_ordering_reverse_order
test_exec!(
syntax(true),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_ordering_reverse_order_exec,
r#"
const calls = [];
function dec(id){
return function(){
calls.push(id);
};
}
@dec(10)
@dec(9)
class Example2 {
@dec(2)
@dec(1)
method1() {};
@dec(4)
@dec(3)
prop1 = 1;
@dec(6)
@dec(5)
method2() {};
@dec(8)
@dec(7)
prop2 = 2;
}
expect(calls).toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
"#
);
// legacy_object_methods_mutate_descriptor
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(true),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_methods_mutate_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let value = descriptor.value;
Object.assign(descriptor, {
enumerable: name.indexOf("enum") !== -1,
configurable: name.indexOf("conf") !== -1,
writable: name.indexOf("write") !== -1,
value: function(...args) {
return "__" + value.apply(this, args) + "__";
},
});
}
const inst = {
@dec
enumconfwrite(){
return 1;
},
@dec
enumconf(){
return 2;
},
@dec
enumwrite(){
return 3;
},
@dec
enum(){
return 4;
},
@dec
confwrite(){
return 5;
},
@dec
conf(){
return 6;
},
@dec
write(){
return 7;
},
@dec
_(){
return 8;
},
}
expect(inst).toHaveProperty('decoratedProps');
expect(inst.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(inst);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(inst.enumconfwrite()).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(inst.enumconf()).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(inst.enumwrite()).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(inst.enum()).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable);
expect(inst.confwrite()).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(inst.conf()).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(inst.write()).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(inst._()).toBe("__8__");
"#
);
// legacy_class_static_methods_return_descriptor
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_static_methods_return_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let value = descriptor.value;
return {
enumerable: name.indexOf('enum') !== -1,
configurable: name.indexOf('conf') !== -1,
writable: name.indexOf('write') !== -1,
value: function(...args){
return '__' + value.apply(this, args) + '__';
},
};
}
class Example {
@dec
static enumconfwrite() {
return 1;
}
@dec
static enumconf() {
return 2;
}
@dec
static enumwrite() {
return 3;
}
@dec
static enum() {
return 4;
}
@dec
static confwrite() {
return 5;
}
@dec
static conf() {
return 6;
}
@dec
static write() {
return 7;
}
@dec
static _() {
return 8;
}
}
expect(Example).toHaveProperty("decoratedProps");
expect(Example.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(Example);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(Example.enumconfwrite()).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(Example.enumconf()).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(Example.enumwrite()).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(Example.enum()).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable);
expect(Example.confwrite()).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(Example.conf()).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(Example.write()).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(Example._()).toBe("__8__");
"#
);
// legacy_object_methods_return_descriptor
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_methods_return_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let value = descriptor.value;
return {
enumerable: name.indexOf('enum') !== -1,
configurable: name.indexOf('conf') !== -1,
writable: name.indexOf('write') !== -1,
value: function(...args){
return '__' + value.apply(this, args) + '__';
},
};
}
const inst = {
@dec
enumconfwrite(){
return 1;
},
@dec
enumconf(){
return 2;
},
@dec
enumwrite(){
return 3;
},
@dec
enum(){
return 4;
},
@dec
confwrite(){
return 5;
},
@dec
conf(){
return 6;
},
@dec
write(){
return 7;
},
@dec
_(){
return 8;
},
}
expect(inst).toHaveProperty('decoratedProps');
expect(inst.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(inst);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(inst.enumconfwrite()).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(inst.enumconf()).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(inst.enumwrite()).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(inst.enum()).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(inst.confwrite()).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(inst.conf()).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(inst.write()).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(inst._()).toBe("__8__");
"#
);
// legacy_object_methods_string_props
test_exec!(
// Legacy decorator for object literals
ignore,
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_object_methods_string_props_exec,
r#"
function dec(target, name, descriptor){
expect(target).toBeTruthy();
expect(name).toBe("str");
expect(typeof descriptor).toBe("object");
}
const inst = {
@dec
"str"(){
}
};
"#
);
// legacy_class_prototype_properties_child_classes_properties
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_prototype_properties_child_classes_properties_exec,
r#"
function dec(target, name, descriptor){
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let initializer = descriptor.initializer;
descriptor.initializer = function(...args){
return "__" + initializer.apply(this, args) + "__";
};
}
class Base {
@dec
prop2 = 4;
}
class Example extends Base {
@dec
prop = 3;
}
let inst = new Example();
expect(inst.prop).toBe("__3__");
expect(inst.prop2).toBe("__4__");
"#
);
// legacy_class_static_methods_mutate_descriptor
test_exec!(
syntax(false),
|_| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
),
legacy_class_static_methods_mutate_descriptor_exec,
r#"
function dec(target, name, descriptor) {
expect(target).toBeTruthy();
expect(typeof name).toBe("string");
expect(typeof descriptor).toBe("object");
target.decoratedProps = (target.decoratedProps || []).concat([name]);
let value = descriptor.value;
Object.assign(descriptor, {
enumerable: name.indexOf("enum") !== -1,
configurable: name.indexOf("conf") !== -1,
writable: name.indexOf("write") !== -1,
value: function(...args) {
return "__" + value.apply(this, args) + "__";
},
});
}
class Example {
@dec
static enumconfwrite(){
return 1;
}
@dec
static enumconf(){
return 2;
}
@dec
static enumwrite(){
return 3;
}
@dec
static enum(){
return 4;
}
@dec
static confwrite(){
return 5;
}
@dec
static conf(){
return 6;
}
@dec
static write(){
return 7;
}
@dec
static _(){
return 8;
}
}
expect(Example).toHaveProperty("decoratedProps");
expect(Example.decoratedProps).toEqual([
"enumconfwrite",
"enumconf",
"enumwrite",
"enum",
"confwrite",
"conf",
"write",
"_",
]);
const descs = Object.getOwnPropertyDescriptors(Example);
expect(descs.enumconfwrite.enumerable).toBeTruthy();
expect(descs.enumconfwrite.writable).toBeTruthy();
expect(descs.enumconfwrite.configurable).toBeTruthy();
expect(Example.enumconfwrite()).toBe("__1__");
expect(descs.enumconf.enumerable).toBeTruthy();
expect(descs.enumconf.writable).toBe(false);
expect(descs.enumconf.configurable).toBeTruthy();
expect(Example.enumconf()).toBe("__2__");
expect(descs.enumwrite.enumerable).toBeTruthy();
expect(descs.enumwrite.writable).toBeTruthy();
expect(descs.enumwrite.configurable).toBe(false);
expect(Example.enumwrite()).toBe("__3__");
expect(descs.enum.enumerable).toBeTruthy();
expect(descs.enum.writable).toBe(false);
expect(descs.enum.configurable).toBe(false);
expect(Example.enum()).toBe("__4__");
expect(descs.confwrite.enumerable).toBe(false);
expect(descs.confwrite.writable).toBeTruthy();
expect(descs.confwrite.configurable).toBeTruthy();
expect(Example.confwrite()).toBe("__5__");
expect(descs.conf.enumerable).toBe(false);
expect(descs.conf.writable).toBe(false);
expect(descs.conf.configurable).toBeTruthy();
expect(Example.conf()).toBe("__6__");
expect(descs.write.enumerable).toBe(false);
expect(descs.write.writable).toBeTruthy();
expect(descs.write.configurable).toBe(false);
expect(Example.write()).toBe("__7__");
expect(descs._.enumerable).toBe(false);
expect(descs._.writable).toBe(false);
expect(descs._.configurable).toBe(false);
expect(Example._()).toBe("__8__");
"#
);
// legacy_regression_8512
test_exec!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
legacy_regression_8512_exec,
r#"
function dec(Class, key, desc) {
return desc;
}
class Foo {
@dec
get bar() {}
}
"#
);
test!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
issue_591_1,
"
export class Example {
@foo() bar = '1';
@foo() baz = '2';
}",
"
var _class, _descriptor, _dec, _descriptor1, _dec1;
export let Example = ((_class = class Example {
constructor(){
_initializerDefineProperty(this, 'bar', _descriptor, this);
_initializerDefineProperty(this, 'baz', _descriptor1, this);
}
}) || _class, _dec = foo(), _dec1 = foo(), _descriptor = \
_applyDecoratedDescriptor(_class.prototype, 'bar', [
_dec
], {
configurable: true,
enumerable: true,
writable: true,
initializer: function() {
return '1';
}
}), _descriptor1 = _applyDecoratedDescriptor(_class.prototype, 'baz', [
_dec1
], {
configurable: true,
enumerable: true,
writable: true,
initializer: function() {
return '2';
}
}), _class);
"
);
test!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
issue_591_2,
"class Example {
@foo() bar = '1';
@foo() baz = '2';
}",
"
var _class, _descriptor, _dec, _descriptor1, _dec1;
let Example = ((_class = class Example {
constructor(){
_initializerDefineProperty(this, 'bar', _descriptor, this);
_initializerDefineProperty(this, 'baz', _descriptor1, this);
}
}) || _class, _dec = foo(), _dec1 = foo(), _descriptor = \
_applyDecoratedDescriptor(_class.prototype, 'bar', [
_dec
], {
configurable: true,
enumerable: true,
writable: true,
initializer: function() {
return '1';
}
}), _descriptor1 = _applyDecoratedDescriptor(_class.prototype, 'baz', [
_dec1
], {
configurable: true,
enumerable: true,
writable: true,
initializer: function() {
return '2';
}
}), _class);
"
);
test!(
Syntax::Typescript(TsConfig {
decorators: true,
..Default::default()
}),
|_| chain!(
decorators(Config {
legacy: true,
..Default::default()
}),
simple_strip()
),
issue_823_1,
"import {Debounce} from 'lodash-decorators';
class Person {
private static debounceTime: number = 500 as const;
@Debounce(Person.debounceTime)
save() {
console.log('Hello World!');
}
}
const p = new Person();
p.save();",
"var _class;
var _class1, _dec;
import { Debounce } from 'lodash-decorators';
let Person = ((_class1 = (_class = class Person {
save() {
console.log('Hello World!');
}
}, _class.debounceTime = 500, _class)) || _class1, _dec = Debounce(_class1.debounceTime), \
_applyDecoratedDescriptor(_class1.prototype, 'save', [
_dec
], Object.getOwnPropertyDescriptor(_class1.prototype, 'save'), _class1.prototype), _class1);
const p = new Person();
p.save();"
);
test!(
Syntax::Typescript(TsConfig {
decorators: true,
..Default::default()
}),
|_| chain!(
decorators(Config {
legacy: true,
..Default::default()
}),
simple_strip(),
// classes(Some(t.comments.clone())),
),
issue_823_2,
"import {Debounce} from 'lodash-decorators';
class Person {
private static debounceTime: number = 500 as const;
@Debounce(Person.debounceTime)
save() {
console.log('Hello World!');
}
}
const p = new Person();
p.save();",
"var _class;
var _class1, _dec;
import { Debounce } from 'lodash-decorators';
let Person = ((_class1 = (_class = class Person {
save() {
console.log('Hello World!');
}
}, _class.debounceTime = 500, _class)) || _class1, _dec = Debounce(_class1.debounceTime), \
_applyDecoratedDescriptor(_class1.prototype, 'save', [
_dec
], Object.getOwnPropertyDescriptor(_class1.prototype, 'save'), _class1.prototype), _class1);
const p = new Person();
p.save();
"
);
test!(
Syntax::Typescript(TsConfig {
decorators: true,
..Default::default()
}),
|t| chain!(
decorators(Config {
legacy: true,
..Default::default()
}),
simple_strip(),
classes(Some(t.comments.clone())),
),
issue_823_3,
"import {Debounce} from 'lodash-decorators';
class Person {
private static debounceTime: number = 500 as const;
@Debounce(Person.debounceTime)
save() {
console.log('Hello World!');
}
}
const p = new Person();
p.save();",
"var _class;
var _class1, _dec;
import { Debounce } from 'lodash-decorators';
let Person = ((_class1 = (_class = function() {
'use strict';
function Person() {
_classCallCheck(this, Person);
}
_createClass(Person, [
{
key: 'save',
value: function save() {
console.log('Hello World!');
}
}
]);
return Person;
}(), _class.debounceTime = 500, _class)) || _class1, _dec = Debounce(_class1.debounceTime), \
_applyDecoratedDescriptor(_class1.prototype, 'save', [
_dec
], Object.getOwnPropertyDescriptor(_class1.prototype, 'save'), _class1.prototype), _class1);
const p = new Person();
p.save();"
);
test!(
ts(),
|_| ts_transform(),
issue_862_1,
"
@Entity()
export class Product extends TimestampedEntity {
@PrimaryGeneratedColumn('uuid')
public id!: string;
@Column()
public price!: number;
@Column({ enum: ProductType })
public type!: ProductType;
@Column()
public productEntityId!: string;
/* ANCHOR: Relations ------------------------------------------------------ */
@OneToMany(() => Order, (order) => order.product)
public orders!: Order[];
@OneToMany(() => Discount, (discount) => discount.product)
public discounts!: Discount[];
}
",
"var _class, _descriptor, _dec, _descriptor1, _dec1, _descriptor2, _dec2, _descriptor3, \
_dec3, _descriptor4, _dec4, _descriptor5, _dec5;
var _dec6 = Entity();
export let Product = _class = _dec6(((_class = class Product extends TimestampedEntity {
constructor(...args){
super(...args);
_initializerDefineProperty(this, 'id', _descriptor, this);
_initializerDefineProperty(this, 'price', _descriptor1, this);
_initializerDefineProperty(this, 'type', _descriptor2, this);
_initializerDefineProperty(this, 'productEntityId', _descriptor3, this);
_initializerDefineProperty(this, 'orders', _descriptor4, this);
_initializerDefineProperty(this, 'discounts', _descriptor5, this);
}
}) || _class, _dec = PrimaryGeneratedColumn('uuid'), _dec1 = Column(), _dec2 = Column({
enum: ProductType
}), _dec3 = Column(), _dec4 = OneToMany(()=>Order
, (order)=>order.product
), _dec5 = OneToMany(()=>Discount
, (discount)=>discount.product
), _descriptor = _applyDecoratedDescriptor(_class.prototype,'id', [
_dec
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0,
}), _descriptor1 = _applyDecoratedDescriptor(_class.prototype, 'price', [
_dec1
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0,
}), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, 'type', [
_dec2
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0,
}), _descriptor3 = _applyDecoratedDescriptor(_class.prototype, 'productEntityId', [
_dec3
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0,
}), _descriptor4 = _applyDecoratedDescriptor(_class.prototype, 'orders', [
_dec4
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0,
}), _descriptor5 = _applyDecoratedDescriptor(_class.prototype, 'discounts', [
_dec5
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0
}), _class)) || _class;
"
);
test!(
ts(),
|_| ts_transform(),
issue_862_2,
"@Entity()
export class Product extends TimestampedEntity {
@PrimaryGeneratedColumn('uuid')
public id!: string;
}
",
"
var _class, _descriptor, _dec;
var _dec1 = Entity();
export let Product = _class = _dec1(((_class = class Product extends TimestampedEntity {
constructor(...args){
super(...args);
_initializerDefineProperty(this, 'id', _descriptor, this);
}
}) || _class, _dec = PrimaryGeneratedColumn('uuid'), _descriptor = \
_applyDecoratedDescriptor(_class.prototype, 'id', [
_dec
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0
}), _class)) || _class;
"
);
test_exec!(
ts(),
|_| ts_transform(),
issue_862_3,
"var log: number[] = [];
function push(x: number) { log.push(x); return x; }
function saveOrder(x: number) {
return function (el: any) {
log.push(x);
return el;
};
}
@saveOrder(1)
class Product {
@saveOrder(0)
public id!: string;
}
var nums = Array.from({ length: 2 }, (_, i) => i);
expect(log).toEqual(nums)"
);
test!(
ts(),
|_| ts_transform(),
issue_863_1,
"class ProductController {
@bar()
findById(
@foo()
id: number
) {
// ...
}
}",
" var _class, _dec;
let ProductController = ((_class = class ProductController {
findById(id) {
}
}) || _class, foo()(_class.prototype, 'findById', 0), _dec = bar(), \
_applyDecoratedDescriptor(_class.prototype, 'findById', [
_dec
], Object.getOwnPropertyDescriptor(_class.prototype, 'findById'), _class.prototype), _class);"
);
test_exec!(
ts(),
|_| ts_transform(),
issue_863_2,
"const logs: number[] = [];
function foo() {
return function (target: any, member: any, ix: any) {
logs.push(0);
};
}
function bar() {
return function (target: any, member: any, ix: any) {
logs.push(1);
};
}
class ProductController {
findById(
@foo()
@bar()
id: number
) {
// ...
}
}
expect(logs).toEqual([0, 1])
const c = new ProductController();
c.findById(100);
"
);
test!(
ts(),
|_| chain!(
inlining::inlining(inlining::Config {}),
decorators(Config {
legacy: true,
..Default::default()
}),
simple_strip(),
),
issue_879_1,
"export default class X {
@networked
prop: string = '';
}",
"var _class, _descriptor;
let X = ((_class = class X {
constructor(){
_initializerDefineProperty(this, 'prop', _descriptor, this);
}
}) || _class, _descriptor = _applyDecoratedDescriptor(_class.prototype, 'prop', [
networked
], {
configurable: true,
enumerable: true,
writable: true,
initializer: function() {
return '';
}
}), _class);
export { X as default };
"
);
test!(
ts(),
|_| decorators(Config {
legacy: true,
emit_metadata: true,
}),
legacy_metadata_generics_base,
"@Decorate
class MyClass {
constructor(
private generic: Generic<A>,
generic2: Generic<A, B>
) {}
@Run
method(
generic: Inter<A>,
@Arg() generic2: InterGen<A, B>
) {}
}",
r#"
var _class, _dec, _dec1, _dec2;
var _dec3 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Generic === "undefined" ? Object : Generic,
typeof Generic === "undefined" ? Object : Generic
]), _dec4 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function);
let MyClass = _class = Decorate(_class = _dec4(_class = _dec3(((_class = class MyClass {
constructor(private generic: Generic<A>, generic2: Generic<A, B>){
}
method(generic: Inter<A>, generic2: InterGen<A, B>) {
}
}) || _class, _dec = function(target, key) {
return Arg()(target, key, 1);
}, _dec1 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec2 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Inter === "undefined" ? Object : Inter,
typeof InterGen === "undefined" ? Object : InterGen
]), _applyDecoratedDescriptor(_class.prototype, "method", [
Run,
_dec,
_dec1,
_dec2
], Object.getOwnPropertyDescriptor(_class.prototype, "method"), _class.prototype), _class)) || _class) || _class) || _class;
"#
);
test!(
ts(),
|_| decorators(Config {
legacy: true,
emit_metadata: true,
}),
legacy_metadata_generics_1,
"@Decorate
class MyClass {
constructor(
private generic: Generic<A>,
generic2: Generic<A, B>
) {}
}",
r#"var _class;
var _dec = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Generic === "undefined" ? Object : Generic,
typeof Generic === "undefined" ? Object : Generic
]), _dec1 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function);
let MyClass = _class = Decorate(_class = _dec1(_class = _dec((_class = class MyClass {
constructor(private generic: Generic<A>, generic2: Generic<A, B>){
}
}) || _class) || _class) || _class) || _class;
"#
);
test!(
ts(),
|_| decorators(Config {
legacy: true,
emit_metadata: true,
}),
legacy_metadata_nest_injection,
"import { AppService } from './app.service';
import { Session, Res } from '@nestjs/common';
import * as express from 'express';
@Controller()
export class AppController {
constructor(private appService: AppService) {}
@Inject()
appService: AppService;
@Inject()
private appService2: AppService;
@Get()
getHello(): string {
return this.appService.getHello();
}
@Get('/callback')
async callback(@Res() res: express.Response, @Session() session: express.Express.Session) {
const token = await this.getToken(code)
const user = await this.getUserInfo(token.access_token)
session.oauth2Token = token
session.user = user
return res.redirect(state.returnUrl ?? '/')
}
}",
r#"
var _class, _descriptor, _dec, _dec1, _descriptor1, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8, _dec9, _dec10, _dec11;
import { AppService } from "./app.service";
import { Session, Res } from "@nestjs/common";
import * as express from "express";
var _dec12 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof AppService === "undefined" ? Object : AppService
]), _dec13 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec14 = Controller();
export let AppController = _class = _dec14(_class = _dec13(_class = _dec12(((_class = class AppController {
constructor(private appService: AppService){
_initializerDefineProperty(this, "appService", _descriptor, this);
_initializerDefineProperty(this, "appService2", _descriptor1, this);
}
getHello(): string {
return this.appService.getHello();
}
async callback(res: express.Response, session: express.Express.Session) {
const token = await this.getToken(code);
const user = await this.getUserInfo(token.access_token);
session.oauth2Token = token;
session.user = user;
return res.redirect(state.returnUrl ?? "/");
}
}) || _class, _dec = Inject(), _dec1 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", typeof AppService === "undefined" ? Object : AppService), _dec2 = Inject(), _dec3 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", typeof AppService === "undefined" ? Object : AppService), _descriptor = _applyDecoratedDescriptor(_class.prototype, "appService", [
_dec,
_dec1
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0
}), _descriptor1 = _applyDecoratedDescriptor(_class.prototype, "appService2", [
_dec2,
_dec3
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0
}), _dec4 = Get(), _dec5 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec6 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", []), _applyDecoratedDescriptor(_class.prototype, "getHello", [
_dec4,
_dec5,
_dec6
], Object.getOwnPropertyDescriptor(_class.prototype, "getHello"), _class.prototype), _dec7 = Get("/callback"), _dec8 = function(target, key) {
return Res()(target, key, 0);
}, _dec9 = function(target, key) {
return Session()(target, key, 1);
}, _dec10 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec11 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof express === "undefined" || typeof express.Response === "undefined" ? Object : express.Response,
typeof express === "undefined" || typeof express.Express === "undefined" || typeof express.Express.Session === "undefined" ? Object : express.Express.Session
]), _applyDecoratedDescriptor(_class.prototype, "callback", [
_dec7,
_dec8,
_dec9,
_dec10,
_dec11
], Object.getOwnPropertyDescriptor(_class.prototype, "callback"), _class.prototype), _class)) || _class) || _class) || _class;
"#
);
test!(
ts(),
|_| decorators(Config {
legacy: true,
emit_metadata: true,
}),
legacy_metadata_parameter_decorated_types,
"class Injected {}
class MyClass {
constructor(@inject() parameter: Injected) {}
}
class MyOtherClass {
constructor(
@inject() private readonly parameter: Injected,
@inject('KIND') otherParam: Injected
) {}
methodUndecorated(@demo() param: string, otherParam) {}
@decorate('named')
method(@inject() param: Injected, @arg() schema: Schema) {}
}
@Decorate
class DecoratedClass {
constructor(
@inject() private readonly module: Injected,
@inject() otherModule: Injected
) {}
@decorate('example')
method(@inject() param: string) {}
}",
r##"
var _class, _class1, _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _class2, _dec8, _dec9, _dec10, _dec11;
class Injected {
}
var _dec12 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Injected === "undefined" ? Object : Injected
]), _dec13 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec14 = function(target, key) {
return inject()(target, undefined, 0);
};
let MyClass = _class = _dec14(_class = _dec13(_class = _dec12((_class = class MyClass {
constructor(parameter: Injected){
}
}) || _class) || _class) || _class) || _class;
var _dec15 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Injected === "undefined" ? Object : Injected,
typeof Injected === "undefined" ? Object : Injected
]), _dec16 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec17 = function(target, key) {
return inject("KIND")(target, undefined, 1);
}, _dec18 = function(target, key) {
return inject()(target, undefined, 0);
};
let MyOtherClass = _class1 = _dec18(_class1 = _dec17(_class1 = _dec16(_class1 = _dec15(((_class1 = class MyOtherClass {
constructor(private readonly parameter: Injected, otherParam: Injected){
}
methodUndecorated(param: string, otherParam) {
}
method(param: Injected, schema: Schema) {
}
}) || _class1, _dec = function(target, key) {
return demo()(target, key, 0);
}, _dec1 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec2 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
String,
void 0
]), _applyDecoratedDescriptor(_class1.prototype, "methodUndecorated", [
_dec,
_dec1,
_dec2
], Object.getOwnPropertyDescriptor(_class1.prototype, "methodUndecorated"), _class1.prototype), _dec3 = decorate("named"), _dec4 = function(target, key) {
return inject()(target, key, 0);
}, _dec5 = function(target, key) {
return arg()(target, key, 1);
}, _dec6 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec7 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Injected === "undefined" ? Object : Injected,
typeof Schema === "undefined" ? Object : Schema
]), _applyDecoratedDescriptor(_class1.prototype, "method", [
_dec3,
_dec4,
_dec5,
_dec6,
_dec7
], Object.getOwnPropertyDescriptor(_class1.prototype, "method"), _class1.prototype), _class1)) || _class1) || _class1) || _class1) || _class1;
var _dec19 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Injected === "undefined" ? Object : Injected,
typeof Injected === "undefined" ? Object : Injected
]), _dec20 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec21 = function(target, key) {
return inject()(target, undefined, 1);
}, _dec22 = function(target, key) {
return inject()(target, undefined, 0);
};
let DecoratedClass = _class2 = Decorate(_class2 = _dec22(_class2 = _dec21(_class2 = _dec20(_class2 = _dec19(((_class2 = class DecoratedClass {
constructor(private readonly module: Injected, otherModule: Injected){
}
method(param: string) {
}
}) || _class2, _dec8 = decorate("example"), _dec9 = function(target, key) {
return inject()(target, key, 0);
}, _dec10 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec11 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
String
]), _applyDecoratedDescriptor(_class2.prototype, "method", [
_dec8,
_dec9,
_dec10,
_dec11
], Object.getOwnPropertyDescriptor(_class2.prototype, "method"), _class2.prototype), _class2)) || _class2) || _class2) || _class2) || _class2) || _class2;
"##
);
test!(
ts(),
|_| decorators(Config {
legacy: true,
emit_metadata: true,
}),
legacy_metadata_type_serialization,
"import { Service } from './service';
import { Decorate } from './Decorate';
const sym = Symbol();
@Decorate()
class Sample {
constructor(
private p0: String,
p1: Number,
p2: 10,
p3: 'ABC',
p4: boolean,
p5: string,
p6: number,
p7: Object,
p8: () => any,
p9: 'abc' | 'def',
p10: String | Number,
p11: Function,
p12: null,
p13: undefined,
p14: any,
p15: (abc: any) => void,
p16: false,
p17: true,
p18: string = 'abc'
) {}
@Decorate
method(
@Arg() p0: Symbol,
p1: typeof sym,
p2: string | null,
p3: never,
p4: string | never,
p5: (string | null),
p6: Maybe<string>,
p7: Object | string,
p8: string & MyStringType,
p9: string[],
p10: [string, number],
p11: void,
p12: this is number,
p13: null | undefined,
p14: (string | (string | null)),
p15: Object,
p16: any,
p17: bigint,
) {}
/**
* Member Expression
*/
@Decorate()
method2(
p0: Decorate.Name = 'abc',
p1: Decorate.Name
) {}
/**
* Assignments
*/
@Decorate()
assignments(
p0: string = 'abc'
) {}
}",
r##"var _class, _dec, _dec1, _dec2, _dec3, _dec4, _dec5, _dec6, _dec7, _dec8;
import { Service } from "./service";
import { Decorate } from "./Decorate";
const sym = Symbol();
var _dec9 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof String === "undefined" ? Object : String,
typeof Number === "undefined" ? Object : Number,
Number,
String,
Boolean,
String,
Number,
typeof Object === "undefined" ? Object : Object,
Function,
String,
Object,
typeof Function === "undefined" ? Object : Function,
void 0,
void 0,
Object,
Function,
Boolean,
Boolean,
void 0
]), _dec10 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec11 = Decorate();
let Sample = _class = _dec11(_class = _dec10(_class = _dec9(((_class = class Sample {
constructor(private p0: String, p1: Number, p2: 10, p3: "ABC", p4: boolean, p5: string, p6: number, p7: Object, p8: () => any, p9: "abc" | "def", p10: String | Number, p11: Function, p12: null, p13: undefined, p14: any, p15: (abc: any) => void, p16: false, p17: true, p18: string = "abc"){
}
method(p0: Symbol, p1: typeof sym, p2: string | null, p3: never, p4: string | never, p5: (string | null), p6: Maybe<string>, p7: Object | string, p8: string & MyStringType, p9: string[], p10: [string, number], p11: void, p12: this is number, p13: null | undefined, p14: (string | (string | null)), p15: Object, p16: any, p17: bigint) {
}
method2(p0: Decorate.Name. = "abc", p1: Decorate.Name.) {
}
assignments(p0: string = "abc") {
}
}) || _class, _dec = function(target, key) {
return Arg()(target, key, 0);
}, _dec1 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec2 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Symbol === "undefined" ? Object : Symbol,
Object,
void 0,
void 0,
void 0,
void 0,
typeof Maybe === "undefined" ? Object : Maybe,
Object,
Object,
Array,
Array,
void 0,
Boolean,
void 0,
Object,
typeof Object === "undefined" ? Object : Object,
Object,
Number
]), _applyDecoratedDescriptor(_class.prototype, "method", [
Decorate,
_dec,
_dec1,
_dec2
], Object.getOwnPropertyDescriptor(_class.prototype, "method"), _class.prototype), _dec3 = Decorate(), _dec4 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec5 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
void 0,
typeof Decorate === "undefined" || typeof Decorate.Name === "undefined" ? Object : Decorate.Name
]), _applyDecoratedDescriptor(_class.prototype, "method2", [
_dec3,
_dec4,
_dec5
], Object.getOwnPropertyDescriptor(_class.prototype, "method2"), _class.prototype), _dec6 = Decorate(), _dec7 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec8 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
void 0
]), _applyDecoratedDescriptor(_class.prototype, "assignments", [
_dec6,
_dec7,
_dec8
], Object.getOwnPropertyDescriptor(_class.prototype, "assignments"), _class.prototype), _class)) || _class) || _class) || _class;"##,
ok_if_code_eq
);
test!(
ts(),
|_| decorators(Config {
legacy: true,
emit_metadata: true,
}),
issue_1160_1,
"
enum MyEnum {
x = \"xxx\",
y = \"yyy\"
}
class Xpto {
@Decorator()
value!: MyEnum;
}
function Decorator() {
return function (...args) {};
}
",
"
var _class, _descriptor, _dec, _dec1;
enum MyEnum {
x = 'xxx',
y = 'yyy'
}
let Xpto = ((_class = class Xpto {
constructor(){
_initializerDefineProperty(this, 'value', _descriptor, this);
}
}) || _class, _dec = Decorator(), _dec1 = typeof Reflect !== 'undefined' && typeof \
Reflect.metadata === 'function' && Reflect.metadata('design:type', String), _descriptor = \
_applyDecoratedDescriptor(_class.prototype, 'value', [
_dec,
_dec1
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0
}), _class);
function Decorator() {
return function(...args) {
};
}
",
ok_if_code_eq
);
// decorators_legacy_interop_local_define_property
test!(
// See: https://github.com/swc-project/swc/issues/421
ignore,
Default::default(),
|t| chain!(
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
class_properties(class_properties::Config { loose: false }),
classes(Some(t.comments.clone()),)
),
decorators_legacy_interop_local_define_property,
r#"
function dec() {}
// Create a local function binding so babel has to change the name of the helper
function _defineProperty() {}
class A {
@dec a;
@dec b = 123;
c = 456;
}
"#,
r#"
var _class, _descriptor, _descriptor2, _temp;
function dec() {} // Create a local function binding so babel has to change the name of the helper
function _defineProperty() {}
let A = (_class = (_temp = function A() {
"use strict";
_classCallCheck(this, A);
_initializerDefineProperty(this, "a", _descriptor, this);
_initializerDefineProperty(this, "b", _descriptor2, this);
_defineProperty2(this, "c", 456);
}, _temp), (_descriptor = _applyDecoratedDescriptor(_class.prototype, "a", [dec], {
configurable: true,
enumerable: true,
writable: true,
initializer: null
}), _descriptor2 = _applyDecoratedDescriptor(_class.prototype, "b", [dec], {
configurable: true,
enumerable: true,
writable: true,
initializer: function () {
return 123;
}
})), _class);
"#
);
fn issue_395_syntax() -> ::swc_ecma_parser::Syntax {
::swc_ecma_parser::Syntax::Es(::swc_ecma_parser::EsConfig {
decorators: true,
..Default::default()
})
}
test!(
issue_395_syntax(),
|_| chain!(
decorators(Default::default()),
common_js(
Mark::fresh(Mark::root()),
common_js::Config {
strict: false,
strict_mode: true,
no_interop: true,
..Default::default()
},
None
),
),
issue_395_1,
"
import Test from './moduleA.js'
@Test('0.0.1')
class Demo {
constructor() {
this.author = 'alan'
}
}
",
"
'use strict';
var _moduleAJs = require('./moduleA.js');
let Demo = _decorate([(0, _moduleAJs).default('0.0.1')], function(_initialize) {
class Demo{
constructor(){
_initialize(this);
this.author = 'alan';
}
}
return {
F: Demo,
d: []
};
});
"
);
test!(
issue_395_syntax(),
|_| chain!(
decorators(Default::default()),
common_js::common_js(
Mark::fresh(Mark::root()),
common_js::Config {
strict: false,
strict_mode: true,
no_interop: true,
..Default::default()
},
None
),
),
issue_395_2,
"
const Test = (version) => {
return (target) => {
target.version = version
}
}
export default Test
",
"
'use strict';
Object.defineProperty(exports, '__esModule', {
value: true
});
exports.default = void 0;
const Test = (version)=>{
return (target)=>{
target.version = version;
};
};
var _default = Test;
exports.default = _default;
"
);
// function_name_function_assignment
test!(
ignore,
Default::default(),
|t| chain!(
resolver(),
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
classes(Some(t.comments.clone())),
function_name(),
),
function_name_function_assignment,
r#"
var foo;
foo = function() {
};
var baz;
baz = function() {
baz();
};
baz = 12;
bar = function() {
bar();
};
"#,
r#"
var foo;
foo = function foo() {};
var _baz;
_baz = function baz() {
_baz();
};
_baz = 12;
bar = function (_bar) {
function bar() {
return _bar.apply(this, arguments);
}
bar.toString = function () {
return _bar.toString();
};
return bar;
}(function () {
bar();
});
"#
);
// function_name_shorthand_property
test!(
// not important
ignore,
Default::default(),
|t| chain!(
resolver(),
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
classes(Some(t.comments.clone())),
function_name(),
),
function_name_shorthand_property,
r#"
var Utils = {
get: function() {}
};
var { get } = Utils;
var bar = {
get: function(arg) {
get(arg, "baz");
}
};
var f = function ({ foo = "bar" }) {
var obj = {
// same name as parameter
foo: function () {
foo;
}
};
};
"#,
r#"
var Utils = {
get: function get() {}
};
var {
get: _get
} = Utils;
var bar = {
get: function get(arg) {
_get(arg, "baz");
}
};
var f = function f({
foo: _foo = "bar"
}) {
var obj = {
// same name as parameter
foo: function foo() {
_foo;
}
};
};
"#
);
// function_name_object
test!(
ignore,
Default::default(),
|t| chain!(
resolver(),
function_name(),
classes(Some(t.comments.clone())),
decorators(decorators::Config {
legacy: true,
..Default::default()
})
),
function_name_object,
r#"
var obj = {
f: function () {
(function f() {
console.log(f);
})();
},
h: function () {
console.log(h);
},
m: function () {
doSmth();
}
};
"#,
r#"
var obj = {
f: function f() {
(function f() {
console.log(f);
})();
},
h: function (_h) {
function h() {
return _h.apply(this, arguments);
}
h.toString = function () {
return _h.toString();
};
return h;
}(function () {
console.log(h);
}),
m: function m() {
doSmth();
}
};
"#
);
// function_name_export
test!(
// not important
ignore,
Default::default(),
|t| chain!(
resolver(),
function_name(),
classes(Some(t.comments.clone())),
decorators(decorators::Config {
legacy: true,
..Default::default()
})
),
function_name_export,
r#"
export var foo = "yes", foob = "no";
export function whatever() {}
export default function wowzers() {}
var bar = {
foo: function () {
foo;
},
whatever: function () {
whatever;
},
wowzers: function () {
wowzers;
}
};
"#,
r#"
var _foo = "yes",
foob = "no";
export { _foo as foo, foob };
function _whatever() {}
export { _whatever as whatever };
function _wowzers() {}
export { _wowzers as default };
var bar = {
foo: function foo() {
_foo;
},
whatever: function whatever() {
_whatever;
},
wowzers: function wowzers() {
_wowzers;
}
};
"#
);
// function_name_global
test!(
// Cost of development is too high.
ignore,
Default::default(),
|t| chain!(
resolver(),
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
function_name(),
classes(Some(t.comments.clone())),
),
function_name_global,
r#"
var test = {
setInterval: function(fn, ms) {
setInterval(fn, ms);
}
};
"#,
r#"
var test = {
setInterval: function (_setInterval) {
function setInterval(_x, _x2) {
return _setInterval.apply(this, arguments);
}
setInterval.toString = function () {
return _setInterval.toString();
};
return setInterval;
}(function (fn, ms) {
setInterval(fn, ms);
})
};
"#
);
// function_name_modules
test!(
Default::default(),
|t| chain!(
resolver(),
decorators(decorators::Config {
legacy: true,
..Default::default()
}),
classes(Some(t.comments.clone())),
function_name(),
common_js(Mark::fresh(Mark::root()), Default::default(), None),
),
function_name_modules,
r#"
import events from "events";
class Template {
events() {
return events;
}
}
console.log(new Template().events());
"#,
r#"
"use strict";
var _events = _interopRequireDefault(require("events"));
let Template =
/*#__PURE__*/
function () {
'use strict';
function Template() {
_classCallCheck(this, Template);
}
_createClass(Template, [{
key: "events",
value: function events() {
return _events.default;
}
}]);
return Template;
}();
console.log(new Template().events());
"#
);
// function_name_eval
test!(
Default::default(),
|t| chain!(
resolver(),
function_name(),
classes(Some(t.comments.clone())),
decorators(decorators::Config {
legacy: true,
..Default::default()
})
),
function_name_eval,
r#"
var a = {
eval: function () {
return eval;
}
};
"#,
r#"
var a = {
eval: function _eval() {
return eval;
}
};
"#
);
test!(
ts(),
|_| decorators(decorators::Config {
legacy: true,
..Default::default()
}),
swc_node_210,
"
class Foo{
@dec
[foo]() {
}
}
",
"
var _class;
let Foo = ((_class = class Foo {
[foo]() {
}
}) || _class, _applyDecoratedDescriptor(_class.prototype, foo, [
dec
], Object.getOwnPropertyDescriptor(_class.prototype, foo), _class.prototype), _class);
"
);
test!(
ts(),
|_| decorators(decorators::Config {
legacy: true,
emit_metadata: true,
..Default::default()
}),
issue_1421_1,
"
class User {
@column() currency!: 'usd' | 'eur' | 'yen';
}
",
"
var _class, _descriptor, _dec, _dec1;
let User = ((_class = class User {
constructor(){
_initializerDefineProperty(this, 'currency', _descriptor, this);
}
}) || _class, _dec = column(), _dec1 = typeof Reflect !== 'undefined' && typeof \
Reflect.metadata === 'function' && Reflect.metadata('design:type', String), _descriptor = \
_applyDecoratedDescriptor(_class.prototype, 'currency', [
_dec,
_dec1
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0
}), _class);
"
);
test!(
ts(),
|_| decorators(decorators::Config {
legacy: true,
emit_metadata: true,
..Default::default()
}),
issue_1456_1,
"
class MyClass {
constructor(@Inject() param1: Injected) {}
}
",
r#"
var _class;
var _dec = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:paramtypes", [
typeof Injected === "undefined" ? Object : Injected
]), _dec1 = typeof Reflect !== "undefined" && typeof Reflect.metadata === "function" && Reflect.metadata("design:type", Function), _dec2 = function(target, key) {
return Inject()(target, undefined, 0);
};
let MyClass = _class = _dec2(_class = _dec1(_class = _dec((_class = class MyClass {
constructor(param1: Injected){
}
}) || _class) || _class) || _class) || _class;
"#
);
test!(
ts(),
|_| decorators(decorators::Config {
..Default::default()
}),
issue_846_1,
"
class SomeClass {
@dec
someMethod() {}
}
class OtherClass extends SomeClass {
@dec
anotherMethod() {
super.someMethod()
}
}
",
"
let SomeClass = _decorate([], function(_initialize) {
class SomeClass {
constructor(){
_initialize(this);
}
}
return {
F: SomeClass,
d: [
{
kind: 'method',
decorators: [
dec
],
key: 'someMethod',
value: function someMethod() {
}
}
]
};
});
let OtherClass = _decorate([], function(_initialize, _SomeClass) {
class OtherClass extends _SomeClass {
constructor(...args){
super(...args);
_initialize(this);
}
}
return {
F: OtherClass,
d: [
{
kind: 'method',
decorators: [
dec
],
key: 'anotherMethod',
value: function anotherMethod() {
_get(_getPrototypeOf(OtherClass.prototype), 'someMethod', this).call(this);
}
}
]
};
}, SomeClass);
"
);
test!(
ts(),
|_| decorators(decorators::Config {
legacy: true,
emit_metadata: true,
..Default::default()
}),
issue_1278_1,
"
function MyDecorator(klass) {
return () => {
// do something
console.log(klass);
}
}
class MyClass {
@MyDecorator(MyClass) prop: '';
}
console.log(new MyClass());
",
"
var _class, _descriptor, _dec, _dec1;
function MyDecorator(klass) {
return ()=>{
console.log(klass);
};
}
let MyClass = ((_class = class MyClass {
constructor(){
_initializerDefineProperty(this, 'prop', _descriptor, this);
}
}) || _class, _dec = MyDecorator(_class), _dec1 = typeof Reflect !== 'undefined' && typeof \
Reflect.metadata === 'function' && Reflect.metadata('design:type', String), _descriptor = \
_applyDecoratedDescriptor(_class.prototype, 'prop', [
_dec,
_dec1
], {
configurable: true,
enumerable: true,
writable: true,
initializer: void 0
}), _class);
console.log(new MyClass());
"
);
test!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
issue_1913_1,
"
class Store {
constructor() {
this.doSomething();
}
@action
doSomething = () => {
console.log('run');
}
}",
"
var _class, _descriptor;
let Store = ((_class = class Store {
constructor(){
_initializerDefineProperty(this, 'doSomething', _descriptor, this);
this.doSomething();
}
}) || _class, _descriptor = _applyDecoratedDescriptor(_class.prototype, 'doSomething', [
action
], {
configurable: true,
enumerable: true,
writable: true,
initializer: function() {
return ()=>{
console.log('run');
};
}
}), _class);
"
);
test!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
issue_1913_2,
"
class Store extends BaseStore{
constructor() {
super();
this.doSomething();
}
@action
doSomething = () => {
console.log('run');
}
}",
"
var _class, _descriptor;
let Store = ((_class = class Store extends BaseStore {
constructor(){
super();
_initializerDefineProperty(this, 'doSomething', _descriptor, this);
this.doSomething();
}
}) || _class, _descriptor = _applyDecoratedDescriptor(_class.prototype, 'doSomething', [
action
], {
configurable: true,
enumerable: true,
writable: true,
initializer: function() {
return ()=>{
console.log('run');
};
}
}), _class);
"
);
test!(
syntax(false),
|_| decorators(Config {
legacy: true,
..Default::default()
}),
issue_1869_1,
"
@someClassDecorator
class TestClass {
static Something = 'hello';
static SomeProperties = {
firstProp: TestClass.Something,
};
}
function someClassDecorator(c) {
return c;
}
",
"
var _class;
let TestClass = _class = someClassDecorator((_class = class TestClass {
static Something = 'hello';
static SomeProperties = {
firstProp: TestClass.Something
};
}) || _class) || _class;
function someClassDecorator(c) {
return c;
}
"
);
test_exec!(
Syntax::Typescript(TsConfig {
decorators: true,
..Default::default()
}),
|_| {
chain!(
decorators(Config {
legacy: true,
emit_metadata: true,
..Default::default()
}),
strip()
)
},
issue_1362_1,
"
const { IsString } = require('class-validator');
class CreateUserDto {
@IsString()
id!: string;
}
"
);
Reference in New Issue View Git Blame Copy Permalink