@opra/common 0.25.4 → 0.26.0

package/cjs/document/api-document.js

@@ -1,240 +1,36 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ApiDocument = void 0;
-const index_js_1 = require("../exception/index.js");
-const index_js_2 = require("../helpers/index.js");
-const index_js_3 = require("../schema/index.js");
-const constants_js_1 = require("./constants.js");
-const complex_type_js_1 = require("./data-type/complex-type.js");
-class ApiDocument {
+const container_js_1 = require("./resource/container.js");
+const type_document_js_1 = require("./type-document.js");
+class ApiDocument extends type_document_js_1.TypeDocument {
     constructor() {
-        this._designCtorMap = new Map();
-        this._typeCache = new index_js_2.ResponsiveMap();
-        this._typesCacheByCtor = new Map();
-        this.references = new index_js_2.ResponsiveMap();
-        this.types = new index_js_2.ResponsiveMap();
-        this.resources = new index_js_2.ResponsiveMap();
-        this.info = {
-            version: '',
-            title: ''
-        };
-        const BigIntConstructor = Object.getPrototypeOf(BigInt(0)).constructor;
-        const BufferConstructor = Object.getPrototypeOf(Buffer.from([]));
-        this._designCtorMap.set(String, 'string');
-        this._designCtorMap.set(Number, 'number');
-        this._designCtorMap.set(Boolean, 'boolean');
-        this._designCtorMap.set(Object, 'any');
-        this._designCtorMap.set(Date, 'timestamp');
-        this._designCtorMap.set(BigIntConstructor, 'bigint');
-        this._designCtorMap.set(ArrayBuffer, 'base64');
-        this._designCtorMap.set(SharedArrayBuffer, 'base64');
-        this._designCtorMap.set(BufferConstructor, 'base64');
-    }
-    /**
-     *
-     */
-    getDataType(arg0, silent) {
-        let dataType;
-        const name = typeof arg0 === 'function' ? arg0.name : String(arg0);
-        // Try to get instance from cache
-        const t = typeof arg0 === 'string'
-            ? this._typeCache.get(arg0)
-            : this._typesCacheByCtor.get(arg0);
-        if (t)
-            return t;
-        // If cached as null, it means "not found"
-        if (t === null) {
-            if (silent)
-                return;
-            throw new Error(`Data type "${name}" does not exists`);
-        }
-        // Convert design ctor to type name (String -> 'string')
-        if (typeof arg0 === 'function') {
-            const x = this._designCtorMap.get(arg0);
-            if (x)
-                arg0 = x;
-        }
-        if (typeof arg0 === 'string') {
-            const m = constants_js_1.NAMESPACE_PATTERN.exec(arg0);
-            if (!m)
-                throw new TypeError(`Invalid data type name "${name}"`);
-            // If given string has namespace pattern (ns:type_name)
-            if (m[2]) {
-                const ref = this.references.get(m[1]);
-                if (!ref) {
-                    if (silent)
-                        return;
-                    throw new Error(`No referenced document found for given namespace "${m[1]}"`);
-                }
-                dataType = ref.getDataType(m[2], silent);
-            }
-            else {
-                // Get instance from own types
-                dataType = this.types.get(arg0);
-                // if not found, search in references (from last to first)
-                if (!dataType) {
-                    const references = Array.from(this.references.values()).reverse();
-                    for (const ref of references) {
-                        dataType = ref.getDataType(name, true);
-                        if (dataType)
-                            break;
-                    }
-                }
-            }
-            if (dataType) {
-                this._typeCache.set(arg0, dataType);
-                return dataType;
-            }
-            if (!silent)
-                throw new index_js_1.NotFoundError(`Data type "${arg0}" does not exists`);
-            return;
-        }
-        if (typeof arg0 === 'function') {
-            const types = Array.from(this.types.values()).reverse();
-            for (const dt of types) {
-                if (dt instanceof complex_type_js_1.ComplexType && dt.isTypeOf(arg0)) {
-                    dataType = dt;
-                    break;
-                }
-            }
-            // if not found, search in references (from last to first)
-            if (!dataType) {
-                const references = Array.from(this.references.values()).reverse();
-                for (const ref of references) {
-                    dataType = ref.getDataType(arg0, true);
-                    if (dataType)
-                        break;
-                }
-            }
-            if (dataType)
-                this._typesCacheByCtor.set(arg0, dataType);
-            if (dataType)
-                return dataType;
-            if (!silent)
-                throw new index_js_1.NotFoundError(`No data type mapping found for class "${name}"`);
-            return;
-        }
-        /* istanbul ignore next */
-        if (!silent)
-            throw new TypeError('Invalid argument');
-    }
-    getComplexType(nameOrCtor, silent) {
-        if (nameOrCtor === Object)
-            nameOrCtor = 'object';
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === index_js_3.OpraSchema.ComplexType.Kind)
-            return t;
-        throw new index_js_1.NotAcceptableError(`Data type "${t.name}" is not a ComplexType`);
-    }
-    getSimpleType(nameOrCtor, silent) {
-        const t = this.getDataType(nameOrCtor);
-        if (!t && silent)
-            return;
-        if (t && t.kind === index_js_3.OpraSchema.SimpleType.Kind)
-            return t;
-        throw new index_js_1.NotAcceptableError(`Data type "${t.name || t}" is not a SimpleType`);
+        super(...arguments);
+        this.root = new container_js_1.Container(this, { name: '' });
     }
     getResource(path, silent) {
-        let resource;
-        const m = constants_js_1.NAMESPACE_PATTERN.exec(path);
-        if (!m)
-            throw new index_js_1.NotFoundError(`Invalid resource path "${path}"`);
-        // If given string has namespace pattern (ns:type_name)
-        if (m[2]) {
-            const ref = this.references.get(m[1]);
-            if (!ref) {
-                if (silent)
-                    return;
-                throw new index_js_1.NotFoundError(`Reference "${m[1]}" not found`);
-            }
-            return ref.getResource(m[2]);
-        }
-        else {
-            const name = m[1];
-            // Get instance from own types
-            resource = this.resources.get(name);
-            if (resource)
-                return resource;
-            // if not found, search in references (from last to first)
-            const references = Array.from(this.references.values()).reverse();
-            for (const ref of references) {
-                resource = silent ? ref.getResource(name, silent) : ref.getResource(name);
-                if (resource)
-                    return resource;
-            }
-        }
-        if (silent)
-            return;
-        throw new index_js_1.ResourceNotFoundError(path);
+        return this.root.getResource(path, silent);
+    }
+    getContainer(path, silent) {
+        return this.root.getContainer(path, silent);
     }
     getCollection(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === index_js_3.OpraSchema.Collection.Kind)
-            return t;
-        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Collection`);
+        return this.root.getCollection(path, silent);
     }
     getSingleton(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === index_js_3.OpraSchema.Singleton.Kind)
-            return t;
-        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Singleton`);
+        return this.root.getSingleton(path, silent);
     }
     getStorage(path, silent) {
-        const t = this.getResource(path);
-        if (!t && silent)
-            return;
-        if (t && t.kind === index_js_3.OpraSchema.Storage.Kind)
-            return t;
-        throw new index_js_1.NotAcceptableError(`Resource type "${t.name}" is not a Storage`);
+        return this.root.getStorage(path, silent);
     }
     /**
      * Export as Opra schema definition object
      */
     exportSchema(options) {
-        if (this._metadataCache)
-            return (0, index_js_2.cloneObject)(this._metadataCache, options?.webSafe);
-        const schema = {
-            version: index_js_3.OpraSchema.SpecVersion,
-            url: this.url,
-            info: (0, index_js_2.cloneObject)(this.info)
-        };
-        if (this.references.size) {
-            const references = {};
-            let i = 0;
-            for (const [ns, r] of this.references.entries()) {
-                if (ns.toLowerCase() === 'opra')
-                    continue;
-                references[ns] = r.url ? r.url : r.exportSchema();
-                i++;
-            }
-            if (i)
-                schema.references = references;
-        }
-        if (this.resources.size) {
-            const resources = schema.resources = {};
-            for (const [name, r] of this.resources.entries()) {
-                resources[name] = r.exportSchema();
-            }
-        }
-        if (this.types.size) {
-            const types = schema.types = {};
-            for (const [name, r] of this.types.entries()) {
-                types[name] = r.exportSchema();
-            }
-        }
-        this._metadataCache = schema;
-        return this._metadataCache;
-    }
-    invalidate() {
-        this._metadataCache = undefined;
-        this._typeCache.clear();
-        this._typesCacheByCtor.clear();
+        const schema = super.exportSchema(options);
+        schema.root = this.root.exportSchema(options);
+        delete schema.root.kind;
+        return schema;
     }
 }
 exports.ApiDocument = ApiDocument;

package/cjs/document/data-type/complex-type-class.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ComplexTypeClass = void 0;
+const tslib_1 = require("tslib");
+const vg = tslib_1.__importStar(require("valgen"));
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../i18n/index.js");
 const index_js_3 = require("../../schema/index.js");
@@ -14,31 +16,38 @@ class ComplexTypeClass extends data_type_js_1.DataType {
         super(document, init);
         this.kind = index_js_3.OpraSchema.ComplexType.Kind;
         const own = this.own = {};
-        own.ctor = init?.ctor || init?.base?.ctor;
-        own.abstract = init?.abstract;
+        own.ctor = init.ctor;
+        if (init.base) {
+            if (!(init.base.kind === 'ComplexType' || init.base.kind === 'MappedType' || init.base.kind === 'UnionType'))
+                throw new TypeError('"base" argument must be one of ComplexType or MappedType or UnionType');
+            own.ctor = own.ctor || init.base.ctor;
+        }
         own.additionalFields = init?.additionalFields;
         own.fields = new index_js_1.ResponsiveMap();
         this.kind = index_js_3.OpraSchema.ComplexType.Kind;
         this.base = init?.base;
         this.ctor = own.ctor || Object;
-        this.abstract = own.abstract;
+        this.abstract = init.abstract;
         this.additionalFields = own.additionalFields;
+        if (this.base?.additionalFields === true && this.additionalFields !== true)
+            this.additionalFields = true;
+        else if (this.base?.additionalFields === 'error' && !this.additionalFields)
+            this.additionalFields = 'error';
         this.fields = new index_js_1.ResponsiveMap();
         if (this.base) {
-            if (this.additionalFields == null)
-                this.additionalFields = this.base.additionalFields;
             if (this.base.fields)
                 for (const [k, el] of this.base.fields.entries()) {
-                    const newEl = new field_js_1.ApiField(this, el);
-                    this.fields.set(k, newEl);
+                    const field = new field_js_1.ApiField(this, el);
+                    this.fields.set(k, field);
                 }
         }
-    }
-    addField(init) {
-        const field = new field_js_1.ApiField(this, init);
-        this.own.fields.set(field.name, field);
-        this.fields.set(field.name, field);
-        return field;
+        if (init.fields) {
+            for (const [k, el] of Object.entries(init.fields)) {
+                const field = new field_js_1.ApiField(this, el);
+                this.own.fields.set(field.name, field);
+                this.fields.set(k, field);
+            }
+        }
     }
     findField(nameOrPath) {
         let field;
@@ -119,24 +128,24 @@ class ComplexTypeClass extends data_type_js_1.DataType {
         }).flat();
         return array.length ? array : undefined;
     }
-    exportSchema() {
-        const out = super.exportSchema();
+    exportSchema(options) {
+        const out = super.exportSchema(options);
         Object.assign(out, (0, index_js_1.omitUndefined)({
             base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            abstract: this.own.abstract,
+                (this.base.name ? this.base.name : this.base.exportSchema(options)) : undefined,
+            abstract: this.abstract,
             additionalFields: this.own.additionalFields
         }));
         if (this.own.fields.size) {
             const fields = out.fields = {};
             for (const field of this.own.fields.values()) {
-                fields[field.name] = field.exportSchema();
+                fields[field.name] = field.exportSchema(options);
             }
         }
         return (0, index_js_1.omitUndefined)(out);
     }
     isTypeOf(t) {
-        return t === this.own.ctor;
+        return t === this.own?.ctor;
     }
     extendsFrom(t) {
         const base = t instanceof data_type_js_1.DataType ? t : this.document.getDataType(t);
@@ -147,5 +156,18 @@ class ComplexTypeClass extends data_type_js_1.DataType {
         }
         return false;
     }
+    generateCodec(codec, options) {
+        const schema = {};
+        for (const f of this.fields.values()) {
+            // todo omit, pick
+            schema[f.name] = f.generateCodec(codec, options);
+        }
+        return vg.isObject(schema, {
+            ctor: this.ctor,
+            additionalFields: this.additionalFields ?? false,
+            name: this.name,
+            caseInSensitive: !options?.caseSensitive
+        });
+    }
 }
 exports.ComplexTypeClass = ComplexTypeClass;

package/cjs/document/data-type/complex-type.js

@@ -5,7 +5,7 @@ const tslib_1 = require("tslib");
 require("reflect-metadata");
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
 const constants_js_1 = require("../constants.js");
-const complex_type_decorator_js_1 = require("../decorators/complex-type.decorator.js");
+const complex_type_decorator_js_1 = require("./complex-type.decorator.js");
 const complex_type_class_js_1 = require("./complex-type-class.js");
 /**
  * @class ComplexType

package/cjs/document/data-type/data-type.js

@@ -15,7 +15,8 @@ class DataType {
         this.description = init?.description;
         this.isAnonymous = !this.name;
     }
-    exportSchema() {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    exportSchema(options) {
         return (0, index_js_1.omitUndefined)({
             kind: this.kind,
             description: this.description

package/cjs/document/data-type/enum-type-class.js

@@ -10,23 +10,26 @@ class EnumTypeClass extends data_type_js_1.DataType {
     constructor(document, init) {
         super(document, init);
         this.kind = index_js_2.OpraSchema.EnumType.Kind;
+        this.enumObject = init.enumObject;
         this.base = init.base;
-        this.ownValues = init.values;
-        this.ownMeanings = init.meanings || {};
+        this.ownValues = { ...init.values };
         this.values = { ...this.base?.values, ...this.ownValues };
-        this.meanings = { ...this.base?.meanings, ...this.ownMeanings };
-        this.decode = vg.isEnum(Object.values(this.values));
-        this.encode = vg.isEnum(Object.values(this.values));
+        this.decode = vg.isEnum(Object.keys(this.values));
+        this.encode = vg.isEnum(Object.keys(this.values));
     }
     exportSchema() {
-        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
-        Object.assign(out, (0, index_js_1.omitUndefined)({
-            base: this.base ?
-                (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-            values: this.ownValues,
-            meanings: this.ownMeanings
-        }));
+        const out = super.exportSchema();
+        out.values = {};
+        Object.entries(this.values).forEach(([k, i]) => {
+            out.values[k] = (0, index_js_1.omitUndefined)({ key: i.key, description: i.description });
+        });
         return out;
     }
+    generateCodec(codec) {
+        if (codec === 'encode')
+            return this.encode;
+        else
+            return this.decode;
+    }
 }
 exports.EnumTypeClass = EnumTypeClass;

package/cjs/document/data-type/enum-type.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.EnumType = void 0;
 const tslib_1 = require("tslib");
 require("reflect-metadata");
-const lodash_omit_1 = tslib_1.__importDefault(require("lodash.omit"));
 const putil_merge_1 = tslib_1.__importDefault(require("putil-merge"));
-const index_js_1 = require("../../schema/index.js");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
 const constants_js_1 = require("../constants.js");
 const enum_type_class_js_1 = require("./enum-type-class.js");
 /**
@@ -15,20 +15,34 @@ exports.EnumType = function (...args) {
     // Injector
     if (!this) {
         const [enumSource, options] = args;
-        const values = Array.isArray(enumSource)
-            ? enumSource.reduce((obj, v) => {
-                obj[v] = v;
-                return obj;
-            }, {})
-            : enumSource;
+        let values = {};
+        if (Array.isArray(enumSource)) {
+            values = {};
+            enumSource.forEach(k => {
+                const description = options?.meanings?.[k];
+                values[k] = (0, index_js_1.omitUndefined)({ description });
+            });
+        }
+        else {
+            Object.keys(enumSource).forEach(k => {
+                const description = options?.meanings?.[k];
+                values[enumSource[k]] = (0, index_js_1.omitUndefined)({ key: k, description });
+            });
+        }
         const metadata = {
-            kind: index_js_1.OpraSchema.EnumType.Kind,
-            values
+            kind: index_js_2.OpraSchema.EnumType.Kind,
+            values,
+            base: options?.base,
+            name: options?.name,
+            description: options?.description
         };
-        if (options)
-            Object.assign(metadata, (0, lodash_omit_1.default)(options, ['kind', 'values']));
-        Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, metadata, enumSource);
-        return values;
+        Object.defineProperty(enumSource, constants_js_1.DATATYPE_METADATA, {
+            value: metadata,
+            enumerable: false,
+            configurable: true,
+            writable: true
+        });
+        return metadata;
     }
     // Constructor
     const [document, init] = args;

package/cjs/document/data-type/field-class.js

@@ -1,13 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FieldClass = void 0;
+const tslib_1 = require("tslib");
+const vg = tslib_1.__importStar(require("valgen"));
 const index_js_1 = require("../../helpers/index.js");
 class FieldClass {
     constructor(owner, init) {
         this.owner = owner;
-        this.name = init.name;
         this.origin = init.origin || owner;
         this.type = init.type;
+        this.name = init.name;
         this.description = init.description;
         this.isArray = init.isArray;
         this.default = init.default;
@@ -17,9 +19,9 @@ class FieldClass {
         this.deprecated = init.deprecated;
         this.examples = init.examples;
     }
-    exportSchema() {
+    exportSchema(options) {
         return (0, index_js_1.omitUndefined)({
-            type: this.type.name ? this.type.name : this.type.exportSchema(),
+            type: this.type.name ? this.type.name : this.type.exportSchema(options),
             description: this.description,
             isArray: this.isArray,
             default: this.default,
@@ -30,5 +32,21 @@ class FieldClass {
             examples: this.examples
         });
     }
+    getDecoder() {
+        if (!this._decoder)
+            this._decoder = this.generateCodec('decode');
+        return this._decoder;
+    }
+    getEncoder() {
+        if (!this._encoder)
+            this._encoder = this.generateCodec('encode');
+        return this._encoder;
+    }
+    generateCodec(codec, options) {
+        let fn = this.type.generateCodec(codec, options);
+        if (this.isArray)
+            fn = vg.isArray(fn);
+        return !options?.partial && this.required ? vg.required(fn) : vg.optional(fn);
+    }
 }
 exports.FieldClass = FieldClass;

package/cjs/document/data-type/field-decorator.js

@@ -4,7 +4,6 @@ exports.FieldDecorator = 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 enum_type_js_1 = require("./enum-type.js");
 function FieldDecorator(options) {
     return function (target, propertyKey) {
         if (typeof propertyKey !== 'string')
@@ -15,30 +14,12 @@ function FieldDecorator(options) {
         const designType = Reflect.getMetadata('design:type', target, propertyKey);
         const elemMeta = metadata.fields[propertyKey] = {
             ...options,
-            enum: undefined,
             designType
         };
         if (designType === Array) {
             elemMeta.isArray = true;
             delete elemMeta.designType;
         }
-        if (options?.enum) {
-            elemMeta.type = undefined;
-            if (Array.isArray(options.enum)) {
-                const enumObj = options.enum.reduce((o, v) => {
-                    o[v] = v;
-                    return o;
-                }, {});
-                (0, enum_type_js_1.EnumType)(enumObj);
-                elemMeta.enum = enumObj;
-            }
-            else {
-                const m = Reflect.getOwnMetadata(constants_js_1.DATATYPE_METADATA, options?.enum);
-                if (!index_js_2.OpraSchema.isEnumType(m))
-                    throw new TypeError(`Invalid "enum" value. Did you forget to set metadata using EnumType() method?`);
-                elemMeta.enum = options.enum;
-            }
-        }
         Reflect.defineMetadata(constants_js_1.DATATYPE_METADATA, (0, index_js_1.omitUndefined)(metadata), target.constructor);
     };
 }

package/cjs/document/data-type/mapped-type-class.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIsInheritedPredicateFn = exports.MappedTypeClass = void 0;
 const index_js_1 = require("../../helpers/index.js");
 const index_js_2 = require("../../schema/index.js");
-const data_type_js_1 = require("./data-type.js");
-class MappedTypeClass extends data_type_js_1.DataType {
+const complex_type_class_js_1 = require("./complex-type-class.js");
+class MappedTypeClass extends complex_type_class_js_1.ComplexTypeClass {
     constructor(document, init) {
         super(document, init);
         this.kind = index_js_2.OpraSchema.MappedType.Kind;
@@ -12,21 +12,19 @@ class MappedTypeClass extends data_type_js_1.DataType {
         own.pick = init.pick;
         own.omit = init.omit;
         this.kind = index_js_2.OpraSchema.MappedType.Kind;
-        this.type = init.type;
         this.pick = own.pick;
         this.omit = own.omit;
-        this.fields = new index_js_1.ResponsiveMap();
-        this.additionalFields = this.type.additionalFields;
         const isInheritedPredicate = getIsInheritedPredicateFn(init.pick, init.omit);
-        for (const [elemName, elem] of this.type.fields.entries()) {
-            if (isInheritedPredicate(elemName))
-                this.fields.set(elemName, elem);
+        for (const fieldName of this.fields.keys()) {
+            if (!isInheritedPredicate(fieldName)) {
+                this.fields.delete(fieldName);
+            }
         }
     }
+    // @ts-ignore
     exportSchema() {
-        const out = data_type_js_1.DataType.prototype.exportSchema.call(this);
+        const out = super.exportSchema();
         Object.assign(out, (0, index_js_1.omitUndefined)({
-            type: this.type.name ? this.type.name : this.type.exportSchema(),
             pick: this.own.pick,
             omit: this.own.omit,
         }));

package/cjs/document/data-type/mapped-type.js

@@ -49,7 +49,7 @@ exports.MappedType = function (...args) {
         throw new TypeError(`Class "${mappedSource}" is not a ${index_js_2.OpraSchema.ComplexType.Kind}`);
     const metadata = {
         kind: 'MappedType',
-        type: mappedSource
+        base: mappedSource
     };
     if (options.pick)
         metadata.pick = options.pick;

package/cjs/document/data-type/simple-type-class.js

@@ -3,7 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleTypeClass = void 0;
 const tslib_1 = require("tslib");
 const vg = tslib_1.__importStar(require("valgen"));
-const index_js_1 = require("../../schema/index.js");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
 const data_type_js_1 = require("./data-type.js");
 /**
  * @class SimpleType
@@ -11,19 +12,27 @@ const data_type_js_1 = require("./data-type.js");
 class SimpleTypeClass extends data_type_js_1.DataType {
     constructor(document, init) {
         super(document, init);
-        this.kind = index_js_1.OpraSchema.SimpleType.Kind;
+        this.kind = index_js_2.OpraSchema.SimpleType.Kind;
         this.base = init.base;
         this.decode = init.decoder || init.base?.decode || vg.isAny();
         this.encode = init.encoder || init.base?.encode || vg.isAny();
     }
-    exportSchema() {
+    exportSchema(options) {
         // noinspection UnnecessaryLocalVariableJS
-        const out = super.exportSchema();
-        // Object.assign(out, omitUndefined({
-        //   base: this.base ?
-        //       (this.base.name ? this.base.name : this.base.exportSchema()) : undefined,
-        // }));
+        const out = super.exportSchema(options);
+        Object.assign(out, (0, index_js_1.omitUndefined)({
+            base: this.base ?
+                (this.base.name ? this.base.name : this.base.exportSchema(options)) : undefined,
+            decode: !options?.webSafe ? this.decode : undefined,
+            encode: !options?.webSafe ? this.encode : undefined
+        }));
         return out;
     }
+    generateCodec(codec) {
+        if (codec === 'encode')
+            return this.encode;
+        else
+            return this.decode;
+    }
 }
 exports.SimpleTypeClass = SimpleTypeClass;