@opra/common 0.15.0 → 0.16.0

package/esm/document/data-type/union-type.js

@@ -1,29 +1,32 @@
-import { applyMixins, inheritPropertyInitializers, omitUndefined, ResponsiveMap } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-import { ComplexType } from './complex-type.js';
-import { DataType } from './data-type.js';
-import { MappedType } from './mapped-type.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnionType = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+const complex_type_js_1 = require("./complex-type.js");
+const data_type_js_1 = require("./data-type.js");
+const mapped_type_js_1 = require("./mapped-type.js");
 /**
  * @class UnionType
  */
-export const UnionType = function (...args) {
+exports.UnionType = function (...args) {
     // UnionType helper
     if (!this) {
         return mapToUnionType(...args);
     }
     // Constructor
     // call super()
-    DataType.apply(this, args);
+    data_type_js_1.DataType.apply(this, args);
     const [, init] = args;
     const _this = this;
-    _this.fields = new ResponsiveMap();
+    _this.fields = new index_js_1.ResponsiveMap();
     const own = _this.own;
     own.types = [];
     for (const base of init.types) {
-        if (!(base instanceof ComplexType || base instanceof UnionType || base instanceof MappedType))
-            throw new TypeError(`${OpraSchema.UnionType.Kind} shall contain ${OpraSchema.ComplexType.Kind}, ` +
-                `${OpraSchema.UnionType.Kind} of ${OpraSchema.MappedType.Kind} types.`);
+        if (!(base instanceof complex_type_js_1.ComplexType || base instanceof exports.UnionType || base instanceof mapped_type_js_1.MappedType))
+            throw new TypeError(`${index_js_2.OpraSchema.UnionType.Kind} shall contain ${index_js_2.OpraSchema.ComplexType.Kind}, ` +
+                `${index_js_2.OpraSchema.UnionType.Kind} of ${index_js_2.OpraSchema.MappedType.Kind} types.`);
         own.types.push(base);
         if (base.additionalFields)
             _this.additionalFields = true;
@@ -32,18 +35,18 @@ export const UnionType = function (...args) {
     _this.kind = 'UnionType';
     _this.types = [...own.types];
 };
-UnionType._applyMixin = () => void 0;
+exports.UnionType._applyMixin = () => void 0;
 const proto = {
     exportSchema() {
-        const out = DataType.prototype.exportSchema.call(this);
-        Object.assign(out, omitUndefined({
+        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
+        Object.assign(out, (0, index_js_1.omitUndefined)({
             types: this.own.types.map(t => t.name ? t.name : t.exportSchema())
         }));
         return out;
     }
 };
-Object.assign(UnionType.prototype, proto);
-Object.setPrototypeOf(UnionType.prototype, DataType.prototype);
+Object.assign(exports.UnionType.prototype, proto);
+Object.setPrototypeOf(exports.UnionType.prototype, data_type_js_1.DataType.prototype);
 /**
  *
  */
@@ -57,22 +60,22 @@ function mapToUnionType(...args) {
     class UnionClass {
         constructor() {
             for (const c of clasRefs)
-                inheritPropertyInitializers(this, c);
+                (0, index_js_1.inheritPropertyInitializers)(this, c);
         }
     }
     const metadata = {
-        kind: OpraSchema.UnionType.Kind,
+        kind: index_js_2.OpraSchema.UnionType.Kind,
         types: []
     };
-    Reflect.defineMetadata(METADATA_KEY, metadata, UnionClass);
+    Reflect.defineMetadata(constants_js_1.METADATA_KEY, metadata, UnionClass);
     for (const c of clasRefs) {
-        const itemMeta = Reflect.getMetadata(METADATA_KEY, c);
-        if (!(itemMeta && (itemMeta.kind === OpraSchema.ComplexType.Kind || itemMeta.kind === OpraSchema.UnionType.Kind ||
-            itemMeta.kind === OpraSchema.MappedType.Kind)))
-            throw new TypeError(`Class "${c.name}" is not a ${OpraSchema.ComplexType.Kind}, ${OpraSchema.UnionType.Kind} or ${OpraSchema.MappedType.Kind}`);
+        const itemMeta = Reflect.getMetadata(constants_js_1.METADATA_KEY, c);
+        if (!(itemMeta && (itemMeta.kind === index_js_2.OpraSchema.ComplexType.Kind || itemMeta.kind === index_js_2.OpraSchema.UnionType.Kind ||
+            itemMeta.kind === index_js_2.OpraSchema.MappedType.Kind)))
+            throw new TypeError(`Class "${c.name}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}, ${index_js_2.OpraSchema.UnionType.Kind} or ${index_js_2.OpraSchema.MappedType.Kind}`);
         metadata.types.push(c);
-        applyMixins(UnionClass, c);
+        (0, index_js_1.applyMixins)(UnionClass, c);
     }
-    UnionType._applyMixin(UnionClass, ...clasRefs);
+    exports.UnionType._applyMixin(UnionClass, ...clasRefs);
     return UnionClass;
 }

package/esm/document/factory/add-references.js

@@ -1,11 +1,14 @@
-import { ApiDocument } from '../api-document.js';
-export async function addReferences(references) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addReferences = void 0;
+const api_document_js_1 = require("../api-document.js");
+async function addReferences(references) {
     const { document } = this;
     for (const [ns, r] of Object.entries(references)) {
         if (typeof r === 'string') {
             document.references.set(ns, await this.createDocumentFromUrl(r));
         }
-        else if (r instanceof ApiDocument)
+        else if (r instanceof api_document_js_1.ApiDocument)
             document.references.set(ns, r);
         else if (typeof r === 'object') {
             document.references.set(ns, await this.createDocument(r));
@@ -14,3 +17,4 @@ export async function addReferences(references) {
             throw new TypeError(`Invalid document reference (${ns}) in schema`);
     }
 }
+exports.addReferences = addReferences;

package/esm/document/factory/create-document.js

@@ -1,6 +1,9 @@
-import { OpraSchema } from '../../schema/index.js';
-import { AnyType, Base64Type, BigIntType, BooleanType, DateType, GuidType, IntegerType, NumberType, ObjectType, StringType } from '../data-type/builtin/index.js';
-export async function createDocument(init, options) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuiltinTypeDocument = exports.createDocumentFromUrl = exports.createDocument = void 0;
+const index_js_1 = require("../../schema/index.js");
+const index_js_2 = require("../data-type/builtin/index.js");
+async function createDocument(init, options) {
     // const {document, typeQueue, curPath, resourceQueue} = this;
     this.document.url = init.url;
     if (init.info)
@@ -37,23 +40,25 @@ export async function createDocument(init, options) {
     this.document.resources.sort();
     return this.document;
 }
+exports.createDocument = createDocument;
 /**
  *
  * @param url
  * @protected
  */
-export async function createDocumentFromUrl(url) {
+async function createDocumentFromUrl(url) {
     const resp = await fetch(url, { method: 'GET' });
     const init = await resp.json();
     if (!init)
         throw new TypeError(`Invalid response returned from url: ${url}`);
     return await this.createDocument({ ...init, url });
 }
-export async function createBuiltinTypeDocument() {
+exports.createDocumentFromUrl = createDocumentFromUrl;
+async function createBuiltinTypeDocument() {
     const init = {
-        version: OpraSchema.SpecVersion,
+        version: index_js_1.OpraSchema.SpecVersion,
         info: {
-            version: OpraSchema.SpecVersion,
+            version: index_js_1.OpraSchema.SpecVersion,
             title: 'Opra built-in types',
             contact: [{
                     url: 'https://github.com/oprajs/opra'
@@ -64,12 +69,13 @@ export async function createBuiltinTypeDocument() {
                 name: 'MIT'
             }
         },
-        types: [AnyType, Base64Type, BigIntType, BooleanType,
-            DateType, GuidType, IntegerType, NumberType,
-            ObjectType, StringType
+        types: [index_js_2.AnyType, index_js_2.Base64Type, index_js_2.BigIntType, index_js_2.BooleanType,
+            index_js_2.DateType, index_js_2.GuidType, index_js_2.IntegerType, index_js_2.NumberType,
+            index_js_2.ObjectType, index_js_2.StringType
         ]
     };
     const factoryClass = Object.getPrototypeOf(this).constructor;
     const factory = new factoryClass();
     return await factory.createDocument(init, { noBuiltinTypes: true });
 }
+exports.createBuiltinTypeDocument = createBuiltinTypeDocument;

package/esm/document/factory/factory.js

@@ -1,20 +1,23 @@
-import { ResponsiveMap } from '../../helpers/index.js';
-import { ApiDocument } from '../api-document.js';
-import { addReferences } from './add-references.js';
-import { createBuiltinTypeDocument, createDocument, createDocumentFromUrl } from './create-document.js';
-import { extractCollectionSchema, extractSingletonSchema, importResourceClass } from './import-resource-class.js';
-import { extractComplexTypeSchema, extractEnumTypeSchema, extractFieldSchema, extractMappedTypeSchema, extractSimpleTypeSchema, extractUnionTypeSchema, importTypeClass } from './import-type-class.js';
-import { createCollection, createSingleton, processResourceQueue } from './process-resources.js';
-import { addDataType, createDataTypeInstance, processTypes } from './process-types.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DocumentFactory = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const api_document_js_1 = require("../api-document.js");
+const add_references_js_1 = require("./add-references.js");
+const create_document_js_1 = require("./create-document.js");
+const import_resource_class_js_1 = require("./import-resource-class.js");
+const import_type_class_js_1 = require("./import-type-class.js");
+const process_resources_js_1 = require("./process-resources.js");
+const process_types_js_1 = require("./process-types.js");
 /**
  * @class DocumentFactory
  */
-export class DocumentFactory {
+class DocumentFactory {
     constructor() {
-        this.document = new ApiDocument();
-        this.typeQueue = new ResponsiveMap();
-        this.resourceQueue = new ResponsiveMap();
-        this.circularRefs = new ResponsiveMap();
+        this.document = new api_document_js_1.ApiDocument();
+        this.typeQueue = new index_js_1.ResponsiveMap();
+        this.resourceQueue = new index_js_1.ResponsiveMap();
+        this.circularRefs = new index_js_1.ResponsiveMap();
         this.curPath = [];
         this.cache = new Map();
     }
@@ -34,25 +37,26 @@ export class DocumentFactory {
         return factory.createDocumentFromUrl(url);
     }
 }
+exports.DocumentFactory = DocumentFactory;
 (() => {
-    DocumentFactory.prototype.createDocument = createDocument;
-    DocumentFactory.prototype.createDocumentFromUrl = createDocumentFromUrl;
-    DocumentFactory.prototype.createBuiltinTypeDocument = createBuiltinTypeDocument;
-    DocumentFactory.prototype.addReferences = addReferences;
-    DocumentFactory.prototype.importTypeClass = importTypeClass;
-    DocumentFactory.prototype.extractSimpleTypeSchema = extractSimpleTypeSchema;
-    DocumentFactory.prototype.extractComplexTypeSchema = extractComplexTypeSchema;
-    DocumentFactory.prototype.extractMappedTypeSchema = extractMappedTypeSchema;
-    DocumentFactory.prototype.extractUnionTypeSchema = extractUnionTypeSchema;
-    DocumentFactory.prototype.extractEnumTypeSchema = extractEnumTypeSchema;
-    DocumentFactory.prototype.extractFieldSchema = extractFieldSchema;
-    DocumentFactory.prototype.processTypes = processTypes;
-    DocumentFactory.prototype.createDataTypeInstance = createDataTypeInstance;
-    DocumentFactory.prototype.addDataType = addDataType;
-    DocumentFactory.prototype.importResourceClass = importResourceClass;
-    DocumentFactory.prototype.extractSingletonSchema = extractSingletonSchema;
-    DocumentFactory.prototype.extractCollectionSchema = extractCollectionSchema;
-    DocumentFactory.prototype.processResourceQueue = processResourceQueue;
-    DocumentFactory.prototype.createCollection = createCollection;
-    DocumentFactory.prototype.createSingleton = createSingleton;
+    DocumentFactory.prototype.createDocument = create_document_js_1.createDocument;
+    DocumentFactory.prototype.createDocumentFromUrl = create_document_js_1.createDocumentFromUrl;
+    DocumentFactory.prototype.createBuiltinTypeDocument = create_document_js_1.createBuiltinTypeDocument;
+    DocumentFactory.prototype.addReferences = add_references_js_1.addReferences;
+    DocumentFactory.prototype.importTypeClass = import_type_class_js_1.importTypeClass;
+    DocumentFactory.prototype.extractSimpleTypeSchema = import_type_class_js_1.extractSimpleTypeSchema;
+    DocumentFactory.prototype.extractComplexTypeSchema = import_type_class_js_1.extractComplexTypeSchema;
+    DocumentFactory.prototype.extractMappedTypeSchema = import_type_class_js_1.extractMappedTypeSchema;
+    DocumentFactory.prototype.extractUnionTypeSchema = import_type_class_js_1.extractUnionTypeSchema;
+    DocumentFactory.prototype.extractEnumTypeSchema = import_type_class_js_1.extractEnumTypeSchema;
+    DocumentFactory.prototype.extractFieldSchema = import_type_class_js_1.extractFieldSchema;
+    DocumentFactory.prototype.processTypes = process_types_js_1.processTypes;
+    DocumentFactory.prototype.createDataTypeInstance = process_types_js_1.createDataTypeInstance;
+    DocumentFactory.prototype.addDataType = process_types_js_1.addDataType;
+    DocumentFactory.prototype.importResourceClass = import_resource_class_js_1.importResourceClass;
+    DocumentFactory.prototype.extractSingletonSchema = import_resource_class_js_1.extractSingletonSchema;
+    DocumentFactory.prototype.extractCollectionSchema = import_resource_class_js_1.extractCollectionSchema;
+    DocumentFactory.prototype.processResourceQueue = process_resources_js_1.processResourceQueue;
+    DocumentFactory.prototype.createCollection = process_resources_js_1.createCollection;
+    DocumentFactory.prototype.createSingleton = process_resources_js_1.createSingleton;
 })();

package/esm/document/factory/import-resource-class.js

@@ -1,27 +1,31 @@
-import { cloneObject, resolveClass, resolveThunk } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-export async function importResourceClass(thunk) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractCollectionSchema = exports.extractSingletonSchema = exports.importResourceClass = void 0;
+require("reflect-metadata");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+async function importResourceClass(thunk) {
     const { document, resourceQueue, cache } = this;
-    const controller = await resolveThunk(thunk);
+    const controller = await (0, index_js_1.resolveThunk)(thunk);
     const cached = cache.get(controller);
     if (cached)
         return cached;
     const ctor = typeof thunk === 'function' ? thunk : Object.getPrototypeOf(thunk).constructor;
-    let metadata = Reflect.getMetadata(METADATA_KEY, ctor);
-    if (!metadata && OpraSchema.isResource(metadata))
+    let metadata = Reflect.getMetadata(constants_js_1.METADATA_KEY, ctor);
+    if (!metadata && index_js_2.OpraSchema.isResource(metadata))
         throw new TypeError(`Class "${ctor.name}" doesn't have a valid Resource metadata`);
     // const controller = typeof thunk === 'function' ? new ctor() : thunk;
     // Clone metadata to prevent changing its contents
-    metadata = cloneObject(metadata);
-    const schema = cloneObject(metadata);
+    metadata = (0, index_js_1.cloneObject)(metadata);
+    const schema = (0, index_js_1.cloneObject)(metadata);
     schema.controller = controller;
     cache.set(thunk, schema);
-    if (OpraSchema.isSingleton(schema) || OpraSchema.isCollection(schema)) {
+    if (index_js_2.OpraSchema.isSingleton(schema) || index_js_2.OpraSchema.isCollection(schema)) {
         if (!document.getDataType(metadata.type, true) && (typeof metadata.type === 'function')) {
             await this.importTypeClass(metadata.type);
             await this.processTypes();
-            const dataTypeCtor = await resolveClass(metadata.type);
+            const dataTypeCtor = await (0, index_js_1.resolveClass)(metadata.type);
             const dataType = document.getComplexType(dataTypeCtor);
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             schema.type = dataType.name;
@@ -29,19 +33,22 @@ export async function importResourceClass(thunk) {
         // Check if data type exists
         document.getComplexType(schema.type);
     }
-    if (OpraSchema.isSingleton(schema))
+    if (index_js_2.OpraSchema.isSingleton(schema))
         await this.extractSingletonSchema(schema, ctor, metadata, controller);
-    if (OpraSchema.isCollection(schema))
+    if (index_js_2.OpraSchema.isCollection(schema))
         await this.extractCollectionSchema(schema, ctor, metadata, controller);
     resourceQueue.set(metadata.name, schema);
 }
-export async function extractSingletonSchema(
+exports.importResourceClass = importResourceClass;
+async function extractSingletonSchema(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 target, ctor, metadata, controller) {
     // Do nothing. This method is used by external modules for extending the factory
 }
-export async function extractCollectionSchema(
+exports.extractSingletonSchema = extractSingletonSchema;
+async function extractCollectionSchema(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 target, ctor, metadata, controller) {
     // Do nothing. This method is used by external modules for extending the factory
 }
+exports.extractCollectionSchema = extractCollectionSchema;

package/esm/document/factory/import-type-class.js

@@ -1,41 +1,46 @@
-import { cloneObject, isConstructor, resolveThunk } from '../../helpers/index.js';
-import { OpraSchema } from '../../schema/index.js';
-import { METADATA_KEY } from '../constants.js';
-export async function importTypeClass(typeThunk) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFieldSchema = exports.extractEnumTypeSchema = exports.extractUnionTypeSchema = exports.extractMappedTypeSchema = exports.extractComplexTypeSchema = exports.extractSimpleTypeSchema = exports.importTypeClass = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const constants_js_1 = require("../constants.js");
+async function importTypeClass(typeThunk) {
     const { document, typeQueue, cache } = this;
-    const thunk = await resolveThunk(typeThunk);
+    const thunk = await (0, index_js_1.resolveThunk)(typeThunk);
     const cached = cache.get(thunk);
     if (cached)
         return cached;
     const dt = document.getDataType(thunk, true);
     if (dt && dt.name)
         return dt.name;
-    const metadata = Reflect.getMetadata(METADATA_KEY, thunk);
-    if (!(metadata && OpraSchema.isDataType(metadata))) {
+    const metadata = Reflect.getMetadata(constants_js_1.METADATA_KEY, thunk);
+    if (!(metadata && index_js_2.OpraSchema.isDataType(metadata))) {
         // If thunk is a Type class
-        if (isConstructor(thunk))
+        if ((0, index_js_1.isConstructor)(thunk))
             throw new TypeError(`Class "${thunk.name}" doesn't have a valid DataType metadata`);
         // If thunk is an Enum object
         throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(thunk).substring(0, 20)}...`);
     }
     // Clone metadata to prevent changing its contents
     const name = metadata.name;
-    const schema = cloneObject(metadata);
+    const schema = (0, index_js_1.cloneObject)(metadata);
     const result = name || schema;
     if (name) {
+        if (this.document.types.has(name) || typeQueue.has(name))
+            throw new TypeError(`Type "${name}" already imported`);
         cache.set(thunk, result);
         typeQueue.set(name, schema);
     }
     // If thunk is a DataType class
-    if (isConstructor(thunk)) {
+    if ((0, index_js_1.isConstructor)(thunk)) {
         const ctor = thunk;
-        if (OpraSchema.isSimpleType(schema))
+        if (index_js_2.OpraSchema.isSimpleType(schema))
             await this.extractSimpleTypeSchema(schema, ctor, metadata);
-        else if (OpraSchema.isComplexType(schema))
+        else if (index_js_2.OpraSchema.isComplexType(schema))
             await this.extractComplexTypeSchema(schema, ctor, metadata);
-        else if (OpraSchema.isMappedType(schema))
+        else if (index_js_2.OpraSchema.isMappedType(schema))
             await this.extractMappedTypeSchema(schema, ctor, metadata);
-        else if (OpraSchema.isUnionType(schema))
+        else if (index_js_2.OpraSchema.isUnionType(schema))
             await this.extractUnionTypeSchema(schema, ctor, metadata);
         else
             throw new TypeError(`Class "${ctor.name}" doesn't have a valid DataType metadata`);
@@ -43,9 +48,9 @@ export async function importTypeClass(typeThunk) {
     }
     // If thunk is a EnumType object
     const enumObject = thunk;
-    if (OpraSchema.isEnumType(schema)) {
+    if (index_js_2.OpraSchema.isEnumType(schema)) {
         let baseType;
-        if (metadata.base && Reflect.hasMetadata(METADATA_KEY, metadata.base)) {
+        if (metadata.base && Reflect.hasMetadata(constants_js_1.METADATA_KEY, metadata.base)) {
             baseType = await this.importTypeClass(metadata.base);
         }
         schema.base = baseType;
@@ -54,17 +59,20 @@ export async function importTypeClass(typeThunk) {
     }
     throw new TypeError(`No EnumType metadata found for object ${JSON.stringify(enumObject).substring(0, 20)}...`);
 }
-export async function extractSimpleTypeSchema(target, ctor, 
+exports.importTypeClass = importTypeClass;
+// noinspection JSUnusedLocalSymbols
+async function extractSimpleTypeSchema(target, ctor, 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+    if (Reflect.hasMetadata(constants_js_1.METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
     target.codec = Object.create(ctor.prototype);
 }
-export async function extractComplexTypeSchema(target, ctor, metadata) {
+exports.extractSimpleTypeSchema = extractSimpleTypeSchema;
+async function extractComplexTypeSchema(target, ctor, metadata) {
     const baseClass = Object.getPrototypeOf(ctor.prototype).constructor;
-    if (Reflect.hasMetadata(METADATA_KEY, baseClass))
+    if (Reflect.hasMetadata(constants_js_1.METADATA_KEY, baseClass))
         target.base = await this.importTypeClass(baseClass);
     target.ctor = ctor;
     // Fields
@@ -80,12 +88,14 @@ export async function extractComplexTypeSchema(target, ctor, metadata) {
                     ...elemMeta,
                     type
                 };
-                if (elemMeta.enum) {
+                if (elemMeta.enum)
                     elemSchema.type = await this.importTypeClass(elemMeta.enum);
-                }
                 if (!elemSchema.type && elemMeta.designType)
                     elemSchema.type = await this.importTypeClass(elemMeta.designType);
                 await this.extractFieldSchema(elemSchema, ctor, elemMeta, elemName);
+                // Check enum again. External packages may modify enum value
+                if (elemMeta.enum)
+                    elemSchema.type = await this.importTypeClass(elemMeta.enum);
                 if (typeof elemSchema.type === 'function')
                     elemSchema.type = await this.importTypeClass(elemSchema.type);
                 if (elemSchema.isArray && !elemSchema.type)
@@ -99,22 +109,29 @@ export async function extractComplexTypeSchema(target, ctor, metadata) {
         }
     }
 }
-export async function extractMappedTypeSchema(target, ctor, metadata) {
+exports.extractComplexTypeSchema = extractComplexTypeSchema;
+async function extractMappedTypeSchema(target, ctor, metadata) {
     target.type = await this.importTypeClass(metadata.type);
 }
-export async function extractUnionTypeSchema(target, ctor, metadata) {
+exports.extractMappedTypeSchema = extractMappedTypeSchema;
+async function extractUnionTypeSchema(target, ctor, metadata) {
     const oldTypes = metadata.types;
     target.types = [];
     for (const type of oldTypes)
         target.types.push(await this.importTypeClass(type));
 }
-export async function extractEnumTypeSchema(
+exports.extractUnionTypeSchema = extractUnionTypeSchema;
+// noinspection JSUnusedLocalSymbols
+async function extractEnumTypeSchema(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 target, enumObject, metadata) {
     // Do nothing. This method is used by external modules for extending the factory
 }
-export async function extractFieldSchema(
+exports.extractEnumTypeSchema = extractEnumTypeSchema;
+// noinspection JSUnusedLocalSymbols
+async function extractFieldSchema(
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 target, ctor, metadata, name) {
     // Do nothing. This method is used by external modules for extending the factory
 }
+exports.extractFieldSchema = extractFieldSchema;

package/esm/document/factory/index.js

@@ -1 +1,4 @@
-export * from './factory.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./factory.js"), exports);

package/esm/document/factory/process-resources.js

@@ -1,7 +1,10 @@
-import { OpraSchema } from '../../schema/index.js';
-import { Collection } from '../resource/collection.js';
-import { Singleton } from '../resource/singleton.js';
-export async function processResourceQueue() {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSingleton = exports.createCollection = exports.processResourceQueue = void 0;
+const index_js_1 = require("../../schema/index.js");
+const collection_js_1 = require("../resource/collection.js");
+const singleton_js_1 = require("../resource/singleton.js");
+async function processResourceQueue() {
     const { document, resourceQueue } = this;
     const resourceNames = Array.from(resourceQueue.keys());
     for (const name of resourceNames) {
@@ -9,12 +12,12 @@ export async function processResourceQueue() {
         if (!schema)
             continue;
         try {
-            if (OpraSchema.isCollection(schema)) {
+            if (index_js_1.OpraSchema.isCollection(schema)) {
                 const resource = await this.createCollection(name, schema);
                 document.resources.set(name, resource);
                 continue;
             }
-            if (OpraSchema.isSingleton(schema)) {
+            if (index_js_1.OpraSchema.isSingleton(schema)) {
                 const resource = await this.createSingleton(name, schema);
                 document.resources.set(name, resource);
                 continue;
@@ -27,7 +30,8 @@ export async function processResourceQueue() {
         throw new TypeError(`Invalid Resource schema: ${JSON.stringify(schema).substring(0, 20)}...`);
     }
 }
-export async function createCollection(name, schema) {
+exports.processResourceQueue = processResourceQueue;
+async function createCollection(name, schema) {
     const { document } = this;
     const dataType = document.getComplexType(schema.type);
     const initArgs = {
@@ -35,9 +39,10 @@ export async function createCollection(name, schema) {
         name,
         type: dataType
     };
-    return new Collection(document, initArgs);
+    return new collection_js_1.Collection(document, initArgs);
 }
-export async function createSingleton(name, schema) {
+exports.createCollection = createCollection;
+async function createSingleton(name, schema) {
     const { document } = this;
     const dataType = document.getComplexType(schema.type);
     const initArgs = {
@@ -45,5 +50,6 @@ export async function createSingleton(name, schema) {
         name,
         type: dataType
     };
-    return new Singleton(document, initArgs);
+    return new singleton_js_1.Singleton(document, initArgs);
 }
+exports.createSingleton = createSingleton;