@river-build/sdk/dist/tests/unit/decorators.test.js

For more details, visit the following resources:

/* eslint-disable @typescript-eslint/no-unsafe-return */
/* eslint-disable @typescript-eslint/no-unsafe-member-access */
// new test with description "decorator tests"
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
import { check, dlogger } from '@river-build/dlog';
const logger = dlogger('csb:test:decorators');
const ALL_NAMES = new Set();
function decoratedWith(options) {
    check(!ALL_NAMES.has(options.fancyName), `duplicate decorator name: ${options.fancyName}`);
    ALL_NAMES.add(options.fancyName);
    return function (constructor) {
        return class extends constructor {
            constructor(...args) {
                super(...args);
                this.baseName = options.fancyName;
            }
            static fancyName = options.fancyName;
        };
    };
}
class Something {
    baseName;
    constructor() {
        this.baseName = '';
        logger.log(name);
    }
}
let MyClass = class MyClass extends Something {
    localName;
    constructor(localName) {
        super();
        this.localName = localName;
    }
};
MyClass = __decorate([
    decoratedWith({ fancyName: 'foo' })
], MyClass);
let MyOtherClass = class MyOtherClass extends Something {
    localName;
    constructor(localName) {
        super();
        this.localName = localName;
    }
};
MyOtherClass = __decorate([
    decoratedWith({ fancyName: 'fooyou' })
], MyOtherClass);
describe('decorator tests', () => {
    test('decorated with', () => {
        const myClass = new MyClass('hello world');
        expect(myClass.baseName).toBe('foo');
        expect(MyClass.fancyName).toBe('foo');
        expect(myClass.localName).toBe('hello world');
        const classes = [MyClass, MyOtherClass];
        const names = classes.map((c) => c.fancyName);
        expect(names).toStrictEqual(['foo', 'fooyou']);
        // expect duplicate decorators to fail
        try {
            let MyBadClass = class MyBadClass extends Something {
            };
            MyBadClass = __decorate([
                decoratedWith({ fancyName: 'foo' })
            ], MyBadClass);
            expect(MyBadClass).toBeUndefined();
        }
        catch (e) {
            expect(e.message).toContain('duplicate decorator name: foo');
        }
    });
});
//# sourceMappingURL=decorators.test.js.map