@epsilon-asi/foundation 0.0.1-testing

package/build/decorators/factory/examples/crud.js

@@ -0,0 +1,120 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crudRegistry = exports.UserCrud = void 0;
+exports.buildCrudSummary = buildCrudSummary;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'crud-example' });
+exports.crudRegistry = registry;
+const Crud = registry.for();
+const Resource = Crud.class('resource');
+const IdField = Crud.property('idField');
+const Route = Crud.method('route');
+let UserCrud = (() => {
+    let _classDecorators = [Resource({ name: 'users' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _get_decorators;
+    let _create_decorators;
+    var UserCrud = _classThis = class {
+        get(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id, email: 'ray@example.com' };
+            });
+        }
+        create(input) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id: 'new-id', email: input.email };
+            });
+        }
+        constructor() {
+            this.id = (__runInitializers(this, _instanceExtraInitializers), __runInitializers(this, _id_initializers, 'user-1'));
+            __runInitializers(this, _id_extraInitializers);
+        }
+    };
+    __setFunctionName(_classThis, "UserCrud");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _id_decorators = [IdField.on('id')];
+        _get_decorators = [Route('get', { method: 'GET', path: '/users/:id' })];
+        _create_decorators = [Route.on('create', { method: 'POST', path: '/users' })];
+        __esDecorate(_classThis, null, _get_decorators, { kind: "method", name: "get", static: false, private: false, access: { has: obj => "get" in obj, get: obj => obj.get }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _create_decorators, { kind: "method", name: "create", static: false, private: false, access: { has: obj => "create" in obj, get: obj => obj.create }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        UserCrud = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return UserCrud = _classThis;
+})();
+exports.UserCrud = UserCrud;
+function buildCrudSummary() {
+    const snapshot = registry.read(UserCrud);
+    const resource = snapshot.firstClass('resource');
+    if (resource === undefined)
+        throw new Error('Missing @Resource metadata.');
+    return {
+        resource: resource.metadata.name,
+        routes: snapshot.methodRecords('route').map((record) => {
+            const metadata = record.metadata;
+            return `${metadata.method} ${metadata.path}`;
+        }),
+        idFields: snapshot.propertyRecords('idField').map((record) => {
+            if (record.memberName === undefined)
+                throw new Error('Missing member name.');
+            return record.memberName;
+        }),
+    };
+}

package/build/decorators/factory/examples/orm.d.ts

@@ -0,0 +1,45 @@
+type OrmDecorators = {
+    class: {
+        entity: {
+            metadata: {
+                table: string;
+            };
+        };
+    };
+    property: {
+        column: {
+            metadata: {
+                type: 'uuid' | 'varchar';
+                primary?: boolean;
+            };
+            target: string;
+        };
+        serializable: {
+            metadata: undefined;
+            target: unknown;
+        };
+    };
+    method: {};
+    accessor: {};
+};
+type UserModelContract = {
+    id: string;
+    email: string;
+};
+declare const registry: import("../types").DecoratorRegistry<OrmDecorators>;
+declare class UserModel implements UserModelContract {
+    id: string;
+    email: string;
+}
+export type TableColumn = {
+    name: string | symbol;
+    type: 'uuid' | 'varchar';
+    primary: boolean;
+};
+export type TableSchema = {
+    table: string;
+    columns: TableColumn[];
+    serializableFields: Array<string | symbol>;
+};
+export declare function buildUserTableSchema(): TableSchema;
+export { UserModel, registry as ormRegistry };

package/build/decorators/factory/examples/orm.js

@@ -0,0 +1,107 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ormRegistry = exports.UserModel = void 0;
+exports.buildUserTableSchema = buildUserTableSchema;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'orm-example' });
+exports.ormRegistry = registry;
+const User = registry.for();
+const Entity = User.class('entity');
+const Column = User.property('column');
+const Serializable = User.property('serializable');
+let UserModel = (() => {
+    let _classDecorators = [Entity({ table: 'users' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _email_decorators;
+    let _email_initializers = [];
+    let _email_extraInitializers = [];
+    var UserModel = _classThis = class {
+        constructor() {
+            this.id = __runInitializers(this, _id_initializers, 'user-1');
+            this.email = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _email_initializers, 'ray@example.com'));
+            __runInitializers(this, _email_extraInitializers);
+        }
+    };
+    __setFunctionName(_classThis, "UserModel");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _id_decorators = [Column('id', { type: 'uuid', primary: true }), Serializable.on('id')];
+        _email_decorators = [Column.on('email', { type: 'varchar' }), Serializable.on('email')];
+        __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+        __esDecorate(null, null, _email_decorators, { kind: "field", name: "email", static: false, private: false, access: { has: obj => "email" in obj, get: obj => obj.email, set: (obj, value) => { obj.email = value; } }, metadata: _metadata }, _email_initializers, _email_extraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        UserModel = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return UserModel = _classThis;
+})();
+exports.UserModel = UserModel;
+function buildUserTableSchema() {
+    const snapshot = registry.read(UserModel);
+    const entity = snapshot.firstClass('entity');
+    if (entity === undefined)
+        throw new Error('Missing @Entity metadata.');
+    const tableMetadata = entity.metadata;
+    const columns = snapshot.propertyRecords('column').map((record) => {
+        var _a, _b;
+        const metadata = record.metadata;
+        return {
+            name: (_a = record.memberName) !== null && _a !== void 0 ? _a : 'unknown',
+            type: metadata.type,
+            primary: (_b = metadata.primary) !== null && _b !== void 0 ? _b : false,
+        };
+    });
+    return {
+        table: tableMetadata.table,
+        columns,
+        serializableFields: snapshot.propertyRecords('serializable').map((record) => {
+            if (record.memberName === undefined)
+                throw new Error('Serializable record missing member.');
+            return record.memberName;
+        }),
+    };
+}

package/build/decorators/factory/examples/routing.d.ts

@@ -0,0 +1,43 @@
+type RouteDecorators = {
+    class: {
+        controller: {
+            metadata: {
+                prefix: string;
+            };
+        };
+    };
+    property: {};
+    method: {
+        route: {
+            metadata: {
+                method: 'GET' | 'POST';
+                path: string;
+            };
+            target: (...args: any[]) => Promise<unknown>;
+        };
+    };
+    accessor: {};
+};
+type UserDto = {
+    id: string;
+    email: string;
+};
+type CreateUserInput = {
+    email: string;
+};
+type UserControllerContract = {
+    getUser(id: string): Promise<UserDto>;
+    createUser(input: CreateUserInput): Promise<UserDto>;
+};
+declare const registry: import("../types").DecoratorRegistry<RouteDecorators>;
+declare class UserController implements UserControllerContract {
+    getUser(id: string): Promise<UserDto>;
+    createUser(input: CreateUserInput): Promise<UserDto>;
+}
+export type RouteEntry = {
+    httpMethod: 'GET' | 'POST';
+    path: string;
+    handlerName: string | symbol;
+};
+export declare function buildRouteTable(): RouteEntry[];
+export { UserController, registry as routeRegistry };

package/build/decorators/factory/examples/routing.js

@@ -0,0 +1,112 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routeRegistry = exports.UserController = void 0;
+exports.buildRouteTable = buildRouteTable;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'route-example' });
+exports.routeRegistry = registry;
+const User = registry.for();
+const Controller = User.class('controller');
+const Route = User.method('route');
+let UserController = (() => {
+    let _classDecorators = [Controller({ prefix: '/api' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _instanceExtraInitializers = [];
+    let _getUser_decorators;
+    let _createUser_decorators;
+    var UserController = _classThis = class {
+        getUser(id) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id, email: 'ray@example.com' };
+            });
+        }
+        createUser(input) {
+            return __awaiter(this, void 0, void 0, function* () {
+                return { id: 'new-id', email: input.email };
+            });
+        }
+        constructor() {
+            __runInitializers(this, _instanceExtraInitializers);
+        }
+    };
+    __setFunctionName(_classThis, "UserController");
+    (() => {
+        const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+        _getUser_decorators = [Route('getUser', { method: 'GET', path: '/users/:id' })];
+        _createUser_decorators = [Route.on('createUser', { method: 'POST', path: '/users' })];
+        __esDecorate(_classThis, null, _getUser_decorators, { kind: "method", name: "getUser", static: false, private: false, access: { has: obj => "getUser" in obj, get: obj => obj.getUser }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(_classThis, null, _createUser_decorators, { kind: "method", name: "createUser", static: false, private: false, access: { has: obj => "createUser" in obj, get: obj => obj.createUser }, metadata: _metadata }, null, _instanceExtraInitializers);
+        __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+        UserController = _classThis = _classDescriptor.value;
+        if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        __runInitializers(_classThis, _classExtraInitializers);
+    })();
+    return UserController = _classThis;
+})();
+exports.UserController = UserController;
+function buildRouteTable() {
+    const snapshot = registry.read(UserController);
+    const controller = snapshot.firstClass('controller');
+    if (controller === undefined)
+        throw new Error('Missing @Controller metadata.');
+    const prefix = controller.metadata.prefix;
+    return snapshot.methodRecords('route').map((record) => {
+        if (record.memberName === undefined)
+            throw new Error('Route record missing member.');
+        const metadata = record.metadata;
+        return {
+            httpMethod: metadata.method,
+            path: `${prefix}${metadata.path}`,
+            handlerName: record.memberName,
+        };
+    });
+}

package/build/decorators/factory/examples/runExamples.d.ts

@@ -0,0 +1 @@
+export {};

package/build/decorators/factory/examples/runExamples.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const accessors_1 = require("./accessors");
+const crud_1 = require("./crud");
+const orm_1 = require("./orm");
+const routing_1 = require("./routing");
+const serialization_1 = require("./serialization");
+function stable(value) {
+    return JSON.stringify(value, (_key, innerValue) => {
+        if (typeof innerValue === 'symbol')
+            return innerValue.toString();
+        return innerValue;
+    });
+}
+const outputs = {
+    orm: (0, orm_1.buildUserTableSchema)(),
+    routing: (0, routing_1.buildRouteTable)(),
+    serialization: (0, serialization_1.serializeUser)(),
+    crud: (0, crud_1.buildCrudSummary)(),
+    accessors: (0, accessors_1.readAccessorMetadata)(),
+};
+console.log(stable(outputs));

package/build/decorators/factory/examples/serialization.d.ts

@@ -0,0 +1,24 @@
+type SerializationDecorators = {
+    class: {};
+    property: {
+        serializable: {
+            metadata: undefined;
+            target: unknown;
+        };
+    };
+    method: {};
+    accessor: {};
+};
+type UserContract = {
+    id: string;
+    email: string;
+    passwordHash: string;
+};
+declare const registry: import("../types").DecoratorRegistry<SerializationDecorators>;
+declare class UserRecord implements UserContract {
+    id: string;
+    email: string;
+    passwordHash: string;
+}
+export declare function serializeUser(user?: UserRecord): Record<string, unknown>;
+export { UserRecord, registry as serializationRegistry };

package/build/decorators/factory/examples/serialization.js

@@ -0,0 +1,79 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializationRegistry = exports.UserRecord = void 0;
+exports.serializeUser = serializeUser;
+const index_1 = require("../index");
+const registry = (0, index_1.createDecoratorRegistry)({ namespace: 'serialization-example' });
+exports.serializationRegistry = registry;
+const User = registry.for();
+const Serializable = User.property('serializable');
+let UserRecord = (() => {
+    var _a;
+    let _id_decorators;
+    let _id_initializers = [];
+    let _id_extraInitializers = [];
+    let _email_decorators;
+    let _email_initializers = [];
+    let _email_extraInitializers = [];
+    return _a = class UserRecord {
+            constructor() {
+                this.id = __runInitializers(this, _id_initializers, 'user-1');
+                this.email = (__runInitializers(this, _id_extraInitializers), __runInitializers(this, _email_initializers, 'ray@example.com'));
+                this.passwordHash = (__runInitializers(this, _email_extraInitializers), 'not-for-output');
+            }
+        },
+        (() => {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _id_decorators = [Serializable.on('id')];
+            _email_decorators = [Serializable.on('email')];
+            __esDecorate(null, null, _id_decorators, { kind: "field", name: "id", static: false, private: false, access: { has: obj => "id" in obj, get: obj => obj.id, set: (obj, value) => { obj.id = value; } }, metadata: _metadata }, _id_initializers, _id_extraInitializers);
+            __esDecorate(null, null, _email_decorators, { kind: "field", name: "email", static: false, private: false, access: { has: obj => "email" in obj, get: obj => obj.email, set: (obj, value) => { obj.email = value; } }, metadata: _metadata }, _email_initializers, _email_extraInitializers);
+            if (_metadata) Object.defineProperty(_a, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        })(),
+        _a;
+})();
+exports.UserRecord = UserRecord;
+function serializeUser(user = new UserRecord()) {
+    const snapshot = registry.read(user);
+    const output = {};
+    for (const record of snapshot.propertyRecords('serializable')) {
+        if (typeof record.memberName !== 'string')
+            continue;
+        output[record.memberName] = user[record.memberName];
+    }
+    return output;
+}

package/build/decorators/factory/index.d.ts

@@ -0,0 +1,3 @@
+export { createDecoratorRegistry } from './decoratorRegistry';
+export { ensureSymbolMetadata, symbolMetadata } from './symbolMetadata';
+export type { AccessorDecoratorDefinition, AnyFunction, ClassDecoratorDefinition, Constructor, CreateDecoratorRegistryOptions, DecorationKind, DecorationRecord, DecoratorRegistry, DecoratorSchema, MethodDecoratorDefinition, MetadataOf, PropertyDecoratorDefinition, RegistryMetadataSnapshot, RegistryReadOptions, ScopedDecoratorBuilder, TargetOf, } from './types';

package/build/decorators/factory/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbolMetadata = exports.ensureSymbolMetadata = exports.createDecoratorRegistry = void 0;
+var decoratorRegistry_1 = require("./decoratorRegistry");
+Object.defineProperty(exports, "createDecoratorRegistry", { enumerable: true, get: function () { return decoratorRegistry_1.createDecoratorRegistry; } });
+var symbolMetadata_1 = require("./symbolMetadata");
+Object.defineProperty(exports, "ensureSymbolMetadata", { enumerable: true, get: function () { return symbolMetadata_1.ensureSymbolMetadata; } });
+Object.defineProperty(exports, "symbolMetadata", { enumerable: true, get: function () { return symbolMetadata_1.symbolMetadata; } });

package/build/decorators/factory/snapshot.d.ts

@@ -0,0 +1,2 @@
+import type { DecorationRecord, RegistryMetadataSnapshot } from './types';
+export declare function createSnapshot(records: readonly DecorationRecord[]): RegistryMetadataSnapshot;

package/build/decorators/factory/snapshot.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSnapshot = createSnapshot;
+function cloneRecords(records) {
+    return Object.freeze(records.slice());
+}
+function filterRecords(records, kind, decorator) {
+    return Object.freeze(records.filter((record) => {
+        if (record.kind !== kind)
+            return false;
+        return decorator === undefined || record.decorator === decorator;
+    }));
+}
+function memberMap(records, kind, decorator) {
+    const mutable = new Map();
+    for (const record of records) {
+        if (record.kind !== kind)
+            continue;
+        if (decorator !== undefined && record.decorator !== decorator)
+            continue;
+        if (record.memberName === undefined)
+            continue;
+        const existing = mutable.get(record.memberName);
+        if (existing === undefined) {
+            mutable.set(record.memberName, [record]);
+        }
+        else {
+            existing.push(record);
+        }
+    }
+    const frozen = new Map();
+    for (const [key, value] of mutable.entries()) {
+        frozen.set(key, Object.freeze(value.slice()));
+    }
+    return frozen;
+}
+function createSnapshot(records) {
+    const sorted = records.slice().sort((left, right) => left.order - right.order);
+    const all = cloneRecords(sorted);
+    const classes = filterRecords(all, 'class');
+    const properties = filterRecords(all, 'property');
+    const methods = filterRecords(all, 'method');
+    const accessors = filterRecords(all, 'accessor');
+    return Object.freeze({
+        all,
+        classes,
+        properties,
+        methods,
+        accessors,
+        firstClass(decorator) {
+            return classes.find((record) => record.decorator === decorator);
+        },
+        classRecords(decorator) {
+            return filterRecords(all, 'class', decorator);
+        },
+        propertyRecords(decorator) {
+            return filterRecords(all, 'property', decorator);
+        },
+        methodRecords(decorator) {
+            return filterRecords(all, 'method', decorator);
+        },
+        accessorRecords(decorator) {
+            return filterRecords(all, 'accessor', decorator);
+        },
+        propertyMap(decorator) {
+            return memberMap(all, 'property', decorator);
+        },
+        methodMap(decorator) {
+            return memberMap(all, 'method', decorator);
+        },
+        accessorMap(decorator) {
+            return memberMap(all, 'accessor', decorator);
+        },
+    });
+}

package/build/decorators/factory/symbolMetadata.d.ts

@@ -0,0 +1,2 @@
+export declare function ensureSymbolMetadata(): symbol;
+export declare const symbolMetadata: symbol;