@opra/core 0.0.5

package/cjs/implementation/adapter/express-adapter.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraExpressAdapter = void 0;
+const url_1 = require("@opra/url");
+const http_adapter_js_1 = require("./http-adapter.js");
+class OpraExpressAdapter extends http_adapter_js_1.OpraHttpAdapter {
+    static init(app, service, options) {
+        const adapter = new OpraExpressAdapter(service, options);
+        const prefix = '/' + (0, url_1.normalizePath)(options?.prefix, true);
+        const userContextResolver = options?.userContext;
+        app.use(prefix, (request, response, next) => {
+            (async () => {
+                const userContext = userContextResolver && await userContextResolver(request);
+                const req = new ExpressRequestWrapper(request);
+                const res = new ExpressResponseWrapper(response);
+                const adapterContext = {
+                    getRequest: () => req,
+                    getResponse: () => res
+                };
+                await adapter.handler(adapterContext, userContext);
+            })().catch(e => next(e));
+        });
+        return adapter;
+    }
+}
+exports.OpraExpressAdapter = OpraExpressAdapter;
+class ExpressRequestWrapper {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getMethod() {
+        return this.instance.method;
+    }
+    getUrl() {
+        return this.instance.url;
+    }
+    getHeaderNames() {
+        return Object.keys(this.instance.headers);
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    getHeaders() {
+        return this.instance.headers;
+    }
+    getBody() {
+        return this.instance.body;
+    }
+}
+class ExpressResponseWrapper {
+    instance;
+    constructor(instance) {
+        this.instance = instance;
+    }
+    getInstance() {
+        return this.instance;
+    }
+    getHeaderNames() {
+        return this.instance.getHeaderNames();
+    }
+    getHeader(name) {
+        return this.instance.get(name);
+    }
+    setHeader(name, value) {
+        this.instance.setHeader(name, value);
+        return this;
+    }
+    getStatus() {
+        return this.instance.statusCode;
+    }
+    setStatus(value) {
+        // noinspection SuspiciousTypeOfGuard
+        this.instance.status(typeof value === 'number'
+            ? value
+            : parseInt(value, 10) || 500);
+        return this;
+    }
+    send(body) {
+        if (typeof body === 'string' || Buffer.isBuffer(body))
+            this.instance.send(body);
+        else
+            this.instance.json(body);
+        return this;
+    }
+    end() {
+        this.instance.end();
+        return this;
+    }
+}

package/cjs/implementation/adapter/http-adapter.js

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraHttpAdapter = void 0;
+const url_1 = require("@opra/url");
+const constants_js_1 = require("../../constants.js");
+const index_js_1 = require("../../enums/index.js");
+const index_js_2 = require("../../exception/index.js");
+const execution_query_interface_js_1 = require("../../interfaces/execution-query.interface.js");
+const headers_js_1 = require("../../utils/headers.js");
+const complex_type_js_1 = require("../data-type/complex-type.js");
+const execution_context_js_1 = require("../execution-context.js");
+const container_resource_controller_js_1 = require("../resource/container-resource-controller.js");
+const entity_resource_info_js_1 = require("../resource/entity-resource-info.js");
+const adapter_js_1 = require("./adapter.js");
+class OpraHttpAdapter extends adapter_js_1.OpraAdapter {
+    prepareExecutionContexts(adapterContext, userContext) {
+        const req = adapterContext.getRequest();
+        // todo implement batch requests
+        if (this.isBatch(adapterContext)) {
+            throw new Error('not implemented yet');
+        }
+        const url = new url_1.OpraURL(req.getUrl());
+        return [this.prepareExecutionContext(adapterContext, url, req.getMethod(), headers_js_1.Headers.from(req.getHeaders()), req.getBody(), userContext)];
+    }
+    prepareExecutionContext(adapterContext, url, method, headers, body, userContext) {
+        if (!url.path.size)
+            throw new index_js_2.BadRequestError();
+        if (method !== 'GET' && url.path.size > 1)
+            throw new index_js_2.BadRequestError();
+        const query = this.buildQuery(url, method, body);
+        if (!query)
+            throw new index_js_2.MethodNotAllowedError({
+                message: `Method "${method}" is not allowed by target resource`
+            });
+        const request = new execution_context_js_1.ExecutionRequest({
+            query,
+            headers,
+            params: url.searchParams,
+        });
+        const response = new execution_context_js_1.ExecutionResponse();
+        // noinspection UnnecessaryLocalVariableJS
+        const executionContext = new execution_context_js_1.ExecutionContext({
+            type: 'http',
+            service: this.service,
+            request,
+            response,
+            adapterContext,
+            userContext,
+            continueOnError: request.query.operationType === 'read'
+        });
+        return executionContext;
+    }
+    buildQuery(url, method, body) {
+        let container = this.service;
+        try {
+            let pathIndex = 0;
+            const pathLen = url.path.size;
+            while (pathIndex < pathLen) {
+                let p = url.path.get(pathIndex++);
+                const resource = container.getResource(p.resource);
+                // Move through path directories (containers)
+                if (resource instanceof container_resource_controller_js_1.ContainerResourceController) {
+                    container = resource;
+                }
+                else {
+                    method = method.toUpperCase();
+                    if (resource instanceof entity_resource_info_js_1.EntityResourceInfo) {
+                        const scope = p.key ? 'instance' : 'collection';
+                        if (pathIndex < pathLen && !(method === 'GET' && scope === 'instance'))
+                            return;
+                        let query;
+                        switch (method) {
+                            case 'GET': {
+                                if (scope === 'collection') {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forSearch(resource, {
+                                        filter: url.searchParams.get('$filter'),
+                                        limit: url.searchParams.get('$limit'),
+                                        skip: url.searchParams.get('$skip'),
+                                        distinct: url.searchParams.get('$distinct'),
+                                        total: url.searchParams.get('$total'),
+                                        sort: url.searchParams.get('$sort'),
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include'),
+                                    });
+                                }
+                                else {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forRead(resource, p.key, {
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include')
+                                    });
+                                    // Move through properties
+                                    let nested;
+                                    let path = resource.name;
+                                    while (pathIndex < pathLen) {
+                                        const dataType = nested
+                                            ? this.service.getDataType(nested.property.type || 'string')
+                                            : query.resource.dataType;
+                                        if (!(dataType instanceof complex_type_js_1.ComplexType))
+                                            throw new Error(`"${path}" is not a ComplexType and has no properties.`);
+                                        p = url.path.get(pathIndex++);
+                                        path += '.' + p.resource;
+                                        const prop = dataType.properties?.[p.resource];
+                                        if (!prop)
+                                            throw new index_js_2.NotFoundError({ message: `Invalid or unknown resource path (${path})` });
+                                        const q = execution_query_interface_js_1.ExecutionQuery.forProperty(prop);
+                                        if (nested) {
+                                            nested.nested = q;
+                                        }
+                                        else {
+                                            query.nested = q;
+                                        }
+                                        nested = q;
+                                    }
+                                }
+                                break;
+                            }
+                            case 'DELETE': {
+                                if (scope === 'collection') {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forDeleteMany(resource, {
+                                        filter: url.searchParams.get('$filter'),
+                                    });
+                                }
+                                else {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forDelete(resource, p.key);
+                                }
+                                break;
+                            }
+                            case 'POST': {
+                                if (scope === 'collection') {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forCreate(resource, body, {
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include')
+                                    });
+                                }
+                                break;
+                            }
+                            case 'PATCH': {
+                                if (scope === 'collection') {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forUpdateMany(resource, body, {
+                                        filter: url.searchParams.get('$filter')
+                                    });
+                                }
+                                else {
+                                    query = execution_query_interface_js_1.ExecutionQuery.forUpdate(resource, p.key, body, {
+                                        pick: url.searchParams.get('$pick'),
+                                        omit: url.searchParams.get('$omit'),
+                                        include: url.searchParams.get('$include')
+                                    });
+                                }
+                                break;
+                            }
+                        }
+                        return query;
+                    }
+                }
+            }
+            throw new index_js_2.InternalServerError();
+        }
+        catch (e) {
+            if (e instanceof index_js_2.ApiException)
+                throw e;
+            throw new index_js_2.BadRequestError({ message: e.message });
+        }
+    }
+    async sendResponse(adapterContext, executionContexts) {
+        const outputPackets = [];
+        for (const ctx of executionContexts) {
+            const v = this.createOutput(ctx);
+            outputPackets.push(v);
+        }
+        if (this.isBatch(adapterContext)) {
+            // this.writeError([], new InternalServerError({message: 'Not implemented yet'}));
+            return;
+        }
+        if (!outputPackets.length) {
+            const err = new index_js_2.NotFoundError();
+            outputPackets.push({
+                status: err.status,
+                body: {
+                    errors: [err.response]
+                }
+            });
+        }
+        const out = outputPackets[0];
+        const resp = adapterContext.getResponse();
+        resp.setStatus(out.status);
+        resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Expires, '-1');
+        resp.setHeader(index_js_1.HttpHeaders.X_Opra_Version, constants_js_1.OpraVersion);
+        if (out.headers) {
+            for (const [k, v] of Object.entries(out.headers)) {
+                resp.setHeader(k, v);
+            }
+        }
+        resp.send(JSON.stringify(out.body));
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isBatch(adapterContext) {
+        return false;
+    }
+    createOutput(ctx) {
+        const { query } = ctx.request;
+        // Determine response status
+        let status = ctx.response.status;
+        if (ctx.response.errors.length) {
+            if (!status || status < 400) {
+                status = 0;
+                for (const e of ctx.response.errors) {
+                    status = Math.max(status, e.status || status);
+                }
+                if (status < index_js_1.HttpStatus.BAD_REQUEST)
+                    status = index_js_1.HttpStatus.INTERNAL_SERVER_ERROR;
+            }
+        }
+        else
+            status = status || (query.operationType === 'create' ? index_js_1.HttpStatus.CREATED : index_js_1.HttpStatus.OK);
+        let body;
+        let value = ctx.response.value;
+        if (query.queryType === 'search') {
+            body = {
+                // '@origin': ctx.resource.name + (ctx.request.resultPath ? '.' + ctx.request.resultPath : ''),
+                items: ctx.response.value,
+                total: ctx.response.total
+            };
+        }
+        else {
+            // Move to sub property if result path defined
+            if (value && ctx.request.resultPath) {
+                const pathArray = ctx.request.resultPath.split('.');
+                for (const property of pathArray) {
+                    value = value && typeof value === 'object' && value[property];
+                }
+            }
+            body = value;
+        }
+        if (ctx.response.errors?.length) {
+            body = body || {};
+            body.errors = ctx.response.errors.map(e => e.response);
+        }
+        return {
+            status,
+            headers: ctx.response.headers,
+            body
+        };
+    }
+    async sendError(adapterContext, error) {
+        const resp = adapterContext.getResponse();
+        resp.setStatus(error.status || 500);
+        resp.setHeader(index_js_1.HttpHeaders.Content_Type, 'application/json');
+        resp.setHeader(index_js_1.HttpHeaders.Cache_Control, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Pragma, 'no-cache');
+        resp.setHeader(index_js_1.HttpHeaders.Expires, '-1');
+        resp.setHeader(index_js_1.HttpHeaders.X_Opra_Version, constants_js_1.OpraVersion);
+        resp.send(JSON.stringify(error.response));
+    }
+}
+exports.OpraHttpAdapter = OpraHttpAdapter;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ComplexType = void 0;
+const responsive_object_js_1 = require("../../utils/responsive-object.js");
+const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
+const data_type_js_1 = require("./data-type.js");
+class ComplexType extends data_type_js_1.DataType {
+    ownProperties;
+    properties;
+    constructor(owner, args, base) {
+        super(owner, {
+            kind: 'ComplexType',
+            ...args
+        }, base);
+        this.ownProperties = args?.properties && (0, responsive_object_js_1.Responsive)(args.properties);
+        this.properties = (base?.properties || this.ownProperties) &&
+            (0, responsive_object_js_1.Responsive)({ ...base?.properties, ...this.ownProperties });
+    }
+    get abstract() {
+        return !!this._args.abstract;
+    }
+    get additionalProperties() {
+        return this._args.additionalProperties;
+    }
+    getProperty(name) {
+        const t = this.properties?.[name];
+        if (!t)
+            throw new Error(`"${this.name}" type has no property named "${name}"`);
+        return t;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [terminal_utils_js_1.nodeInspectCustom]() {
+        return `[${terminal_utils_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + terminal_utils_js_1.colorReset}` +
+            ` ${terminal_utils_js_1.colorFgMagenta + this.name + terminal_utils_js_1.colorReset}]`;
+    }
+}
+exports.ComplexType = ComplexType;

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

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataType = void 0;
+class DataType {
+    _owner;
+    _args;
+    base;
+    constructor(owner, args, base) {
+        this._args = { ...args };
+        this._owner = owner;
+        if (base) {
+            this.base = base;
+            Object.setPrototypeOf(this._args, base._args);
+        }
+    }
+    get owner() {
+        return this._owner;
+    }
+    get kind() {
+        return this._args.kind;
+    }
+    get name() {
+        return this._args.name;
+    }
+    get description() {
+        return this._args.description;
+    }
+    get ctor() {
+        return this._args.ctor;
+    }
+    is(typeName) {
+        return this.name === typeName || !!(this.base && this.base.is(typeName));
+    }
+}
+exports.DataType = DataType;

package/cjs/implementation/data-type/entity-type.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityType = void 0;
+const optionals_1 = require("@opra/optionals");
+const complex_type_js_1 = require("./complex-type.js");
+class EntityType extends complex_type_js_1.ComplexType {
+    constructor(owner, args, base) {
+        super(owner, {
+            ...args
+        }, base);
+        this._args.kind = 'EntityType';
+        // Try to determine primary key info from SQB
+        if (args.ctor) {
+            const sqbEntity = optionals_1.SqbConnect.EntityMetadata.get(args.ctor);
+            if (sqbEntity?.indexes) {
+                const primaryIndex = sqbEntity.indexes.find(x => x.primary);
+                if (primaryIndex) {
+                    if (primaryIndex.columns.length > 1)
+                        throw new TypeError(`Multi-key indexes is not implemented yet`);
+                    this._args.primaryKey = primaryIndex.columns[0];
+                }
+            }
+        }
+        if (!this.primaryKey)
+            throw new TypeError(`You must provide primaryKey fo "${this.name}" entity`);
+        if (!this.getProperty(this.primaryKey))
+            throw new TypeError(`"${this.name}" entity has no such property named "${this.primaryKey}" which defined as primary key`);
+    }
+    get primaryKey() {
+        return this._args.primaryKey;
+    }
+}
+exports.EntityType = EntityType;

package/cjs/implementation/data-type/simple-type.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleType = void 0;
+const terminal_utils_js_1 = require("../../utils/terminal-utils.js");
+const data_type_js_1 = require("./data-type.js");
+class SimpleType extends data_type_js_1.DataType {
+    constructor(owner, args, base) {
+        super(owner, {
+            kind: 'SimpleType',
+            ...args
+        }, base);
+    }
+    get type() {
+        return this._args.type;
+    }
+    get format() {
+        return this._args.format;
+    }
+    get default() {
+        return this._args.default;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [terminal_utils_js_1.nodeInspectCustom]() {
+        return `[${terminal_utils_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + terminal_utils_js_1.colorReset}` +
+            ` ${terminal_utils_js_1.colorFgMagenta + this.name + terminal_utils_js_1.colorReset}]`;
+    }
+}
+exports.SimpleType = SimpleType;

package/cjs/implementation/execution-context.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExecutionResponse = exports.ExecutionRequest = exports.ExecutionContext = void 0;
+const url_1 = require("@opra/url");
+const headers_js_1 = require("../utils/headers.js");
+class ExecutionContext {
+    type;
+    service;
+    request;
+    response;
+    adapterContext;
+    userContext;
+    continueOnError;
+    constructor(args) {
+        Object.assign(this, args);
+    }
+    switchToHttp() {
+        if (this.type !== 'http')
+            throw new Error(`You can't access http context within an ${this.type} context`);
+        return this.adapterContext;
+    }
+}
+exports.ExecutionContext = ExecutionContext;
+class ExecutionRequest {
+    query;
+    params;
+    headers;
+    parentValue;
+    resultPath;
+    constructor(args) {
+        Object.assign(this, args);
+        this.params = this.params || new url_1.OpraURLSearchParams();
+        this.headers = this.headers || headers_js_1.Headers.create();
+        this.resultPath = this.resultPath || '';
+    }
+}
+exports.ExecutionRequest = ExecutionRequest;
+class ExecutionResponse {
+    headers = headers_js_1.Headers.create();
+    errors = [];
+    status;
+    value;
+    total;
+    constructor(args) {
+        if (args)
+            Object.assign(this, args);
+    }
+}
+exports.ExecutionResponse = ExecutionResponse;

package/cjs/implementation/opra-document.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpraDocument = void 0;
+const tslib_1 = require("tslib");
+const lodash_1 = tslib_1.__importDefault(require("lodash"));
+const schema_1 = require("@opra/schema");
+const internal_data_types_js_1 = require("../utils/internal-data-types.js");
+const responsive_object_js_1 = require("../utils/responsive-object.js");
+const terminal_utils_js_1 = require("../utils/terminal-utils.js");
+const complex_type_js_1 = require("./data-type/complex-type.js");
+const entity_type_js_1 = require("./data-type/entity-type.js");
+const simple_type_js_1 = require("./data-type/simple-type.js");
+const schema_generator_js_1 = require("./schema-generator.js");
+class OpraDocument {
+    _args;
+    _types = (0, responsive_object_js_1.Responsive)();
+    constructor(schema) {
+        this._args = lodash_1.default.omit(schema, 'types');
+        if (schema.types)
+            this._addDataTypes(schema.types);
+    }
+    get name() {
+        return this._args.info?.title || '';
+    }
+    get info() {
+        return this._args.info;
+    }
+    get types() {
+        return this._types;
+    }
+    getDataType(name) {
+        const t = this.types[name];
+        if (!t)
+            throw new Error(`Data type "${name}" does not exists`);
+        return t;
+    }
+    getComplexDataType(name) {
+        const t = this.getDataType(name);
+        if (!(t instanceof complex_type_js_1.ComplexType))
+            throw new Error(`Data type "${name}" is not a ComplexType`);
+        return t;
+    }
+    getEntityDataType(name) {
+        const t = this.getDataType(name);
+        if (!(t instanceof entity_type_js_1.EntityType))
+            throw new Error(`Data type "${name}" is not an EntityType`);
+        return t;
+    }
+    getSimpleDataType(name) {
+        const t = this.getDataType(name);
+        if (!(t instanceof simple_type_js_1.SimpleType))
+            throw new Error(`Data type "${name}" is not a SimpleType`);
+        return t;
+    }
+    toString() {
+        return `[${Object.getPrototypeOf(this).constructor.name} ${this.name}]`;
+    }
+    [terminal_utils_js_1.nodeInspectCustom]() {
+        return `[${terminal_utils_js_1.colorFgYellow + Object.getPrototypeOf(this).constructor.name + terminal_utils_js_1.colorReset}` +
+            ` ${terminal_utils_js_1.colorFgMagenta + this.name + terminal_utils_js_1.colorReset}]`;
+    }
+    static async create(args) {
+        const schema = await schema_generator_js_1.SchemaGenerator.generateDocumentSchema(args);
+        return new OpraDocument(schema);
+    }
+    _addDataTypes(dataTypes) {
+        const recursiveSet = new Set();
+        const nameSet = new Set(dataTypes.map(x => x.name));
+        const processDataType = (schema) => {
+            if ((!internal_data_types_js_1.internalDataTypes.has(schema.name) && !nameSet.has(schema.name)) || this.types[schema.name])
+                return;
+            if (recursiveSet.has(schema.name))
+                throw new TypeError(`Recursive dependency detected. ${Array.from(recursiveSet).join('>')}`);
+            recursiveSet.add(schema.name);
+            let baseType;
+            if (schema.base) {
+                if (!this.types[schema.base]) {
+                    const baseSchema = dataTypes.find(dt => dt.name.toLowerCase() === schema.base?.toLowerCase()) ||
+                        internal_data_types_js_1.internalDataTypes.get(schema.base.toLowerCase());
+                    if (!baseSchema)
+                        throw new TypeError(`Base schema (${schema.base}) of data type "${schema.name}" does not exists`);
+                    baseType = processDataType(baseSchema);
+                }
+            }
+            let dataType;
+            if (schema_1.OpraSchema.isSimpleType(schema)) {
+                if (baseType && !(baseType instanceof simple_type_js_1.SimpleType))
+                    throw new TypeError(`Can't extend a SimpleType (${schema.name}) from a ComplexType "${baseType.name}"`);
+                dataType = new simple_type_js_1.SimpleType(this, schema, baseType);
+            }
+            else if (schema_1.OpraSchema.isComplexType(schema)) {
+                if (baseType && !(baseType instanceof complex_type_js_1.ComplexType))
+                    throw new TypeError(`Can't extend a ComplexType (${schema.name}) from a SimpleType "${baseType.name}"`);
+                dataType = new complex_type_js_1.ComplexType(this, schema, baseType);
+            }
+            else if (schema_1.OpraSchema.isEntityType(schema)) {
+                if (baseType && !(baseType instanceof complex_type_js_1.ComplexType))
+                    throw new TypeError(`Can't extend an EntityType (${schema.name}) from a SimpleType "${baseType.name}"`);
+                dataType = new entity_type_js_1.EntityType(this, schema, baseType);
+            }
+            else
+                throw new TypeError(`Invalid data type schema`);
+            nameSet.delete(schema.name);
+            this.types[dataType.name] = dataType;
+            recursiveSet.delete(schema.name);
+            return dataType;
+        };
+        dataTypes.forEach(dataType => processDataType(dataType));
+        // Sort data types by name
+        const newTypes = (0, responsive_object_js_1.Responsive)();
+        Object.keys(this.types).sort()
+            .forEach(name => newTypes[name] = this.types[name]);
+        this._types = newTypes;
+    }
+}
+exports.OpraDocument = OpraDocument;