@opra/client 0.13.0 → 0.15.0

package/esm/mime-types-79c091fd.js

@@ -0,0 +1,199 @@
+import { g as getDefaultExportFromCjs } from './content-disposition-65f281a9.js';
+import { m as mimeDb } from './mime-db-d0f15d8f.js';
+import path from 'path-browserify';
+
+var mimeTypes = {};
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+(function (exports) {
+
+	/**
+	 * Module dependencies.
+	 * @private
+	 */
+
+	var db = mimeDb;
+	var extname = path.extname;
+
+	/**
+	 * Module variables.
+	 * @private
+	 */
+
+	var EXTRACT_TYPE_REGEXP = /^\s*([^;\s]*)(?:;|\s|$)/;
+	var TEXT_TYPE_REGEXP = /^text\//i;
+
+	/**
+	 * Module exports.
+	 * @public
+	 */
+
+	exports.charset = charset;
+	exports.charsets = { lookup: charset };
+	exports.contentType = contentType;
+	exports.extension = extension;
+	exports.extensions = Object.create(null);
+	exports.lookup = lookup;
+	exports.types = Object.create(null);
+
+	// Populate the extensions/types maps
+	populateMaps(exports.extensions, exports.types);
+
+	/**
+	 * Get the default charset for a MIME type.
+	 *
+	 * @param {string} type
+	 * @return {boolean|string}
+	 */
+
+	function charset (type) {
+	  if (!type || typeof type !== 'string') {
+	    return false
+	  }
+
+	  // TODO: use media-typer
+	  var match = EXTRACT_TYPE_REGEXP.exec(type);
+	  var mime = match && db[match[1].toLowerCase()];
+
+	  if (mime && mime.charset) {
+	    return mime.charset
+	  }
+
+	  // default text/* to utf-8
+	  if (match && TEXT_TYPE_REGEXP.test(match[1])) {
+	    return 'UTF-8'
+	  }
+
+	  return false
+	}
+
+	/**
+	 * Create a full Content-Type header given a MIME type or extension.
+	 *
+	 * @param {string} str
+	 * @return {boolean|string}
+	 */
+
+	function contentType (str) {
+	  // TODO: should this even be in this module?
+	  if (!str || typeof str !== 'string') {
+	    return false
+	  }
+
+	  var mime = str.indexOf('/') === -1
+	    ? exports.lookup(str)
+	    : str;
+
+	  if (!mime) {
+	    return false
+	  }
+
+	  // TODO: use content-type or other module
+	  if (mime.indexOf('charset') === -1) {
+	    var charset = exports.charset(mime);
+	    if (charset) mime += '; charset=' + charset.toLowerCase();
+	  }
+
+	  return mime
+	}
+
+	/**
+	 * Get the default extension for a MIME type.
+	 *
+	 * @param {string} type
+	 * @return {boolean|string}
+	 */
+
+	function extension (type) {
+	  if (!type || typeof type !== 'string') {
+	    return false
+	  }
+
+	  // TODO: use media-typer
+	  var match = EXTRACT_TYPE_REGEXP.exec(type);
+
+	  // get extensions
+	  var exts = match && exports.extensions[match[1].toLowerCase()];
+
+	  if (!exts || !exts.length) {
+	    return false
+	  }
+
+	  return exts[0]
+	}
+
+	/**
+	 * Lookup the MIME type for a file path/extension.
+	 *
+	 * @param {string} path
+	 * @return {boolean|string}
+	 */
+
+	function lookup (path) {
+	  if (!path || typeof path !== 'string') {
+	    return false
+	  }
+
+	  // get the extension ("ext" or ".ext" or full path)
+	  var extension = extname('x.' + path)
+	    .toLowerCase()
+	    .substr(1);
+
+	  if (!extension) {
+	    return false
+	  }
+
+	  return exports.types[extension] || false
+	}
+
+	/**
+	 * Populate the extensions and types maps.
+	 * @private
+	 */
+
+	function populateMaps (extensions, types) {
+	  // source preference (least -> most)
+	  var preference = ['nginx', 'apache', undefined, 'iana'];
+
+	  Object.keys(db).forEach(function forEachMimeType (type) {
+	    var mime = db[type];
+	    var exts = mime.extensions;
+
+	    if (!exts || !exts.length) {
+	      return
+	    }
+
+	    // mime -> extensions
+	    extensions[type] = exts;
+
+	    // extension -> mime
+	    for (var i = 0; i < exts.length; i++) {
+	      var extension = exts[i];
+
+	      if (types[extension]) {
+	        var from = preference.indexOf(db[types[extension]].source);
+	        var to = preference.indexOf(mime.source);
+
+	        if (types[extension] !== 'application/octet-stream' &&
+	          (from > to || (from === to && types[extension].substr(0, 12) === 'application/'))) {
+	          // skip the remapping
+	          continue
+	        }
+	      }
+
+	      // set the extension -> mime
+	      types[extension] = type;
+	    }
+	  });
+	} 
+} (mimeTypes));
+
+var mime = /*@__PURE__*/getDefaultExportFromCjs(mimeTypes);
+
+export { mime as m };

package/esm/safe-buffer-63383356.js

@@ -0,0 +1,76 @@
+import require$$0 from 'buffer';
+
+var safeBuffer = {exports: {}};
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+(function (module, exports) {
+	/* eslint-disable node/no-deprecated-api */
+	var buffer = require$$0;
+	var Buffer = buffer.Buffer;
+
+	// alternative to using Object.keys for old browsers
+	function copyProps (src, dst) {
+	  for (var key in src) {
+	    dst[key] = src[key];
+	  }
+	}
+	if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
+	  module.exports = buffer;
+	} else {
+	  // Copy properties from require('buffer')
+	  copyProps(buffer, exports);
+	  exports.Buffer = SafeBuffer;
+	}
+
+	function SafeBuffer (arg, encodingOrOffset, length) {
+	  return Buffer(arg, encodingOrOffset, length)
+	}
+
+	SafeBuffer.prototype = Object.create(Buffer.prototype);
+
+	// Copy static methods from Buffer
+	copyProps(Buffer, SafeBuffer);
+
+	SafeBuffer.from = function (arg, encodingOrOffset, length) {
+	  if (typeof arg === 'number') {
+	    throw new TypeError('Argument must not be a number')
+	  }
+	  return Buffer(arg, encodingOrOffset, length)
+	};
+
+	SafeBuffer.alloc = function (size, fill, encoding) {
+	  if (typeof size !== 'number') {
+	    throw new TypeError('Argument must be a number')
+	  }
+	  var buf = Buffer(size);
+	  if (fill !== undefined) {
+	    if (typeof encoding === 'string') {
+	      buf.fill(fill, encoding);
+	    } else {
+	      buf.fill(fill);
+	    }
+	  } else {
+	    buf.fill(0);
+	  }
+	  return buf
+	};
+
+	SafeBuffer.allocUnsafe = function (size) {
+	  if (typeof size !== 'number') {
+	    throw new TypeError('Argument must be a number')
+	  }
+	  return Buffer(size)
+	};
+
+	SafeBuffer.allocUnsafeSlow = function (size) {
+	  if (typeof size !== 'number') {
+	    throw new TypeError('Argument must be a number')
+	  }
+	  return buffer.SlowBuffer(size)
+	}; 
+} (safeBuffer, safeBuffer.exports));
+
+var safeBufferExports = safeBuffer.exports;
+
+export { safeBufferExports as s };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/client",
-  "version": "0.13.0",
+  "version": "0.15.0",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",
@@ -31,19 +31,25 @@
     "@browsery/i18next": "^0.2.0",
     "@browsery/stream": "^0.2.0",
     "@browsery/util": "^0.2.0",
+    "accepts": "^1.3.8",
     "buffer": "^6.0.3",
+    "crypto-browserify": "^3.12.0",
+    "cookie": "^0.5.0",
+    "dayjs": "^1.11.7",
+    "encodeurl": "^1.0.2",
     "events": "^3.3.0",
-    "fast-tokenizer": "^1.2.1",
+    "fast-tokenizer": "^1.2.2",
     "lodash.omit": "^4.5.0",
     "path-browserify": "^1.0.1",
     "process": "^0.11.10",
     "putil-isplainobject": "^1.1.5",
-    "putil-merge": "^3.10.1",
+    "putil-merge": "^3.10.3",
     "putil-promisify": "^1.10.0",
     "putil-varhelpers": "^1.6.5",
     "reflect-metadata": "^0.1.13",
     "rxjs": "^7.8.0",
     "ts-lib": "^0.0.5",
+    "type-is": "^1.6.18",
     "uid": "^2.0.1"
   },
   "devDependencies": {},

package/typings/common/document/api-document.d.ts

@@ -0,0 +1,102 @@
+import { Type } from 'ts-gems';
+import { ResponsiveMap } from '../helpers/index.js';
+import { OpraSchema } from '../schema/index.js';
+import { ComplexType } from './data-type/complex-type.js';
+import type { DataType } from './data-type/data-type.js';
+import { SimpleType } from './data-type/simple-type.js';
+import type { Collection } from './resource/collection.js';
+import { Resource } from './resource/resource.js';
+import { Singleton } from './resource/singleton.js';
+export declare class ApiDocument {
+    protected _typeCache: ResponsiveMap<DataType | null>;
+    protected _typesCacheByCtor: Map<object | Type<any>, DataType | null>;
+    url?: string;
+    info: OpraSchema.DocumentInfo;
+    references: ResponsiveMap<ApiDocument>;
+    types: ResponsiveMap<DataType>;
+    resources: ResponsiveMap<Resource>;
+    constructor();
+    /**
+     * Returns DataType instance by name or Constructor. Returns undefined if not found
+     * @param nameOrCtor
+     * @param silent
+     */
+    getDataType(nameOrCtor: string | Type | object, silent: true): DataType | undefined;
+    /**
+     * Returns DataType instance by name or Constructor. Throws error  if not found
+     * @param nameOrCtor
+     */
+    getDataType(nameOrCtor: string | Type | object): DataType;
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a ComplexType
+     * @param nameOrCtor
+     * @param silent
+     */
+    getComplexType(nameOrCtor: string | Type, silent: true): ComplexType | undefined;
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Throws error undefined if not found or data type is not a ComplexType
+     * @param nameOrCtor
+     */
+    getComplexType(nameOrCtor: string | Type): ComplexType;
+    /**
+     * Returns SimpleType instance by name or Constructor.
+     * Returns undefined if not found
+     * Throws error if data type is not a SimpleType
+     * @param nameOrCtor
+     * @param silent
+     */
+    getSimpleType(nameOrCtor: string | Type, silent: true): SimpleType | undefined;
+    /**
+     Returns SimpleType instance by name or Constructor.
+     Throws error undefined if not found or data type is not a SimpleType
+     * @param nameOrCtor
+     */
+    getSimpleType(nameOrCtor: string | Type): SimpleType;
+    /**
+     * Returns Resource instance by path. Returns undefined if not found
+     * @param path
+     * @param silent
+     */
+    getResource(path: string, silent: boolean): Resource | undefined;
+    /**
+     * Returns Resource instance by path. Throws error if not found
+     * @param path
+     */
+    getResource(path: string): Resource;
+    /**
+     * Returns Collection resource instance by path
+     * Returns undefined if not found
+     * Throws error if resource is not a Collection
+     * @param path
+     * @param silent
+     */
+    getCollection(path: string, silent: true): Collection | undefined;
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Throws error undefined if not found or data type is not a ComplexType
+     * @param path
+     */
+    getCollection(path: string): Collection;
+    /**
+     * Returns Singleton resource instance by path
+     * Returns undefined if not found
+     * Throws error if resource is not a Collection
+     * @param path
+     * @param silent
+     */
+    getSingleton(path: string, silent: true): Singleton | undefined;
+    /**
+     * Returns ComplexType instance by name or Constructor.
+     * Throws error undefined if not found or data type is not a ComplexType
+     * @param path
+     */
+    getSingleton(path: string): Singleton;
+    /**
+     * Export as Opra schema definition object
+     */
+    exportSchema(): OpraSchema.ApiDocument;
+    invalidate(): void;
+}

package/typings/common/document/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const METADATA_KEY: unique symbol;
+export declare const NAMESPACE_PATTERN: RegExp;
+export declare const TYPENAME_PATTERN: RegExp;

package/typings/common/document/data-type/api-field.d.ts

@@ -0,0 +1,41 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import { TypeThunkAsync } from '../../types.js';
+import type { ComplexType } from './complex-type.js';
+import { DataType } from './data-type.js';
+export declare namespace ApiField {
+    interface InitArguments extends StrictOmit<OpraSchema.Field, 'type'> {
+        name: string;
+        type: DataType;
+        origin?: ComplexType;
+    }
+    interface DecoratorOptions extends Partial<StrictOmit<OpraSchema.Field, 'isArray' | 'type'>> {
+        type?: string | OpraSchema.DataType | TypeThunkAsync;
+        enum?: OpraSchema.EnumObject | string[];
+    }
+    interface Metadata extends StrictOmit<OpraSchema.Field, 'type'> {
+        type?: string | OpraSchema.DataType | TypeThunkAsync;
+        enum?: OpraSchema.EnumObject;
+        designType?: Type;
+    }
+}
+export interface ApiField extends StrictOmit<OpraSchema.Field, 'type'> {
+    readonly owner: ComplexType;
+    readonly origin?: ComplexType;
+    readonly type: DataType;
+    readonly name: string;
+    exportSchema(): OpraSchema.Field;
+}
+/**
+ * Type definition of ComplexType constructor type
+ * @type ApiFieldConstructor
+ */
+export interface ApiFieldConstructor {
+    new (owner: ComplexType, init: ApiField.InitArguments): ApiField;
+    (options?: ApiField.DecoratorOptions): PropertyDecorator;
+    prototype: ApiField;
+}
+/**
+ * @class ComplexType
+ */
+export declare const ApiField: ApiFieldConstructor;

package/typings/common/document/data-type/builtin/any.type.d.ts

@@ -0,0 +1,2 @@
+export declare class AnyType {
+}

package/typings/common/document/data-type/builtin/base64.type.d.ts

@@ -0,0 +1,6 @@
+export declare class Base64Type {
+    decode(v: any): ArrayBuffer | undefined;
+    encode(v: any): string | undefined;
+    coerce(v: any): ArrayBuffer | undefined;
+    validate(v: any): void;
+}

package/typings/common/document/data-type/builtin/bigint.type.d.ts

@@ -0,0 +1,6 @@
+export declare class BigIntType {
+    decode(v: any): bigint | undefined;
+    encode(v: any): string | undefined;
+    coerce(v: any): bigint | undefined;
+    validate(v: any): void;
+}

package/typings/common/document/data-type/builtin/boolean.type.d.ts

@@ -0,0 +1,5 @@
+export declare class BooleanType {
+    decode(v: any): boolean | undefined;
+    encode(v: any): boolean | undefined;
+    coerce(v: any): boolean | undefined;
+}

package/typings/common/document/data-type/builtin/date.type.d.ts

@@ -0,0 +1,4 @@
+import { TimestampType } from './timestamp.type.js';
+export declare class DateType extends TimestampType {
+    format: string;
+}

package/typings/common/document/data-type/builtin/guid.type.d.ts

@@ -0,0 +1,7 @@
+import { StringType } from './string.type.js';
+export declare class GuidType extends StringType {
+    decode(v: any): string | undefined;
+    encode(v: any): string | undefined;
+    coerce(v: any): string | undefined;
+    validate(v: string): void;
+}

package/typings/common/document/data-type/builtin/index.d.ts

@@ -0,0 +1,10 @@
+export * from './any.type.js';
+export * from './base64.type.js';
+export * from './bigint.type.js';
+export * from './boolean.type.js';
+export * from './date.type.js';
+export * from './guid.type.js';
+export * from './integer.type.js';
+export * from './number.type.js';
+export * from './object.type.js';
+export * from './string.type.js';

package/typings/common/document/data-type/builtin/integer.type.d.ts

@@ -0,0 +1,6 @@
+import { NumberType } from './number.type.js';
+export declare class IntegerType extends NumberType {
+    decode(v: any): number | undefined;
+    encode(v: any): number | undefined;
+    coerce(v: any): number | undefined;
+}

package/typings/common/document/data-type/builtin/number.type.d.ts

@@ -0,0 +1,6 @@
+export declare class NumberType {
+    decode(v: any): number | undefined;
+    encode(v: any): number | undefined;
+    coerce(v: any): number | undefined;
+    validate(v: any): void;
+}

package/typings/common/document/data-type/builtin/object.type.d.ts

@@ -0,0 +1,3 @@
+export declare class ObjectType {
+    coerce(v: any): {} | undefined;
+}

package/typings/common/document/data-type/builtin/string.type.d.ts

@@ -0,0 +1,5 @@
+export declare class StringType {
+    decode(v: any): string | undefined;
+    encode(v: any): string | undefined;
+    coerce(v: any): string | undefined;
+}

package/typings/common/document/data-type/builtin/time.type.d.ts

@@ -0,0 +1,7 @@
+import { StringType } from './string.type.js';
+export declare class TimeType extends StringType {
+    decode(v: any): string | undefined;
+    encode(v: any): string | undefined;
+    coerce(v: any): string | undefined;
+    validate(v: string): void;
+}

package/typings/common/document/data-type/builtin/timestamp.type.d.ts

@@ -0,0 +1,5 @@
+export declare class TimestampType {
+    format: string;
+    decode(v: any): Date | undefined;
+    encode(v: any): string | undefined;
+}

package/typings/common/document/data-type/complex-type.d.ts

@@ -0,0 +1,50 @@
+import { StrictOmit, Type } from 'ts-gems';
+import { ResponsiveMap } from '../../helpers/index.js';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { ApiField } from './api-field.js';
+import { DataType } from './data-type.js';
+import type { UnionType } from './union-type';
+/**
+ * @namespace ComplexType
+ */
+export declare namespace ComplexType {
+    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.ComplexType, 'ctor' | 'abstract' | 'additionalFields'> {
+        base?: ComplexType | UnionType;
+    }
+    interface OwnProperties extends DataType.OwnProperties, Readonly<Pick<OpraSchema.ComplexType, 'ctor' | 'abstract' | 'additionalFields'>> {
+        readonly fields: ResponsiveMap<ApiField>;
+    }
+    interface DecoratorOptions extends DataType.DecoratorOptions, Pick<InitArguments, 'ctor' | 'base' | 'additionalFields' | 'abstract'> {
+    }
+    interface Metadata extends StrictOmit<OpraSchema.ComplexType, 'fields'> {
+        name: string;
+        fields?: Record<string, ApiField.Metadata>;
+    }
+}
+/**
+ * Type definition of ComplexType prototype
+ * @type ComplexType
+ */
+export interface ComplexType extends StrictOmit<DataType, 'own' | 'exportSchema'>, ComplexType.OwnProperties {
+    readonly ctor: Type;
+    readonly base?: ComplexType | UnionType;
+    readonly own: ComplexType.OwnProperties;
+    exportSchema(): OpraSchema.ComplexType;
+    addField(init: ApiField.InitArguments): ApiField;
+    getField(name: string): ApiField;
+    normalizeFieldNames(fields: string | string[]): string[] | undefined;
+}
+/**
+ * Type definition of ComplexType constructor type
+ * @type ComplexTypeConstructor
+ */
+export interface ComplexTypeConstructor {
+    new (document: ApiDocument, init: ComplexType.InitArguments): ComplexType;
+    (options?: ComplexType.DecoratorOptions): ClassDecorator;
+    prototype: ComplexType;
+}
+/**
+ * @class ComplexType
+ */
+export declare const ComplexType: ComplexTypeConstructor;

package/typings/common/document/data-type/data-type.d.ts

@@ -0,0 +1,33 @@
+import { Type } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { nodeInspectCustom } from '../utils/inspect.util.js';
+export declare namespace DataType {
+    interface InitArguments extends Partial<Pick<OpraSchema.DataTypeBase, 'description'>> {
+        name?: string;
+    }
+    interface OwnProperties {
+        description?: string;
+    }
+    interface DecoratorOptions extends Pick<InitArguments, 'name' | 'description'> {
+    }
+}
+export interface DataType extends DataType.OwnProperties {
+    readonly document: ApiDocument;
+    readonly kind: OpraSchema.DataType.Kind;
+    readonly name?: string;
+    readonly own: DataType.OwnProperties;
+    readonly isAnonymous: boolean;
+    coerce(value: any): any;
+    validate(v: any): void;
+    extendsFrom(t: string | Type | DataType): boolean;
+    exportSchema(): OpraSchema.DataType;
+    toString(): string;
+    [nodeInspectCustom](): string;
+}
+export interface DataTypeConstructor {
+    new (document: ApiDocument, init?: DataType.InitArguments): DataType;
+    (...args: any[]): void;
+    prototype: DataType;
+}
+export declare const DataType: DataTypeConstructor;

package/typings/common/document/data-type/enum-type.d.ts

@@ -0,0 +1,32 @@
+import { StrictOmit } from 'ts-gems';
+import { OpraSchema } from '../../schema/index.js';
+import type { ApiDocument } from '../api-document.js';
+import { DataType } from './data-type.js';
+export declare namespace EnumType {
+    interface InitArguments extends DataType.InitArguments, Pick<OpraSchema.EnumType, 'base' | 'values' | 'meanings'> {
+        base?: EnumType;
+    }
+    interface OwnProperties extends DataType.OwnProperties, Required<Readonly<Pick<OpraSchema.EnumType, 'values' | 'meanings'>>> {
+    }
+    interface Options<T, Keys extends (string | number | symbol) = T extends readonly any[] ? T[number] : keyof T> extends DataType.DecoratorOptions {
+        name?: string;
+        base?: OpraSchema.EnumObject;
+        meanings?: Record<Keys, string>;
+    }
+    interface Metadata extends OpraSchema.EnumType {
+        name: string;
+    }
+}
+export interface EnumType extends StrictOmit<DataType, 'own' | 'exportSchema'>, EnumType.OwnProperties {
+    readonly base?: EnumType;
+    readonly own: EnumType.OwnProperties;
+    exportSchema(): OpraSchema.EnumType;
+}
+export interface EnumTypeConstructor {
+    new (document: ApiDocument, init?: EnumType.InitArguments): EnumType;
+    <T extends OpraSchema.EnumObject | readonly (string | number)[]>(target: T, options?: EnumType.Options<T>): T;
+}
+/**
+ * @class EnumType
+ */
+export declare const EnumType: EnumTypeConstructor;