@opra/client 0.16.2 → 0.17.1

package/{cjs/mime-db-c6221216.js → esm/mime-db-d0f15d8f.js}

@@ -1,5 +1,3 @@
-'use strict';
-
 var require$$0 = {
 	"application/1d-interleaved-parityfec": {
 	source: "iana"
@@ -10710,18 +10708,10 @@ var require$$0 = {
  * MIT Licensed
  */
 
-var mimeDb;
-var hasRequiredMimeDb;
-
-function requireMimeDb () {
-	if (hasRequiredMimeDb) return mimeDb;
-	hasRequiredMimeDb = 1;
-	/**
-	 * Module exports.
-	 */
+/**
+ * Module exports.
+ */
 
-	mimeDb = require$$0;
-	return mimeDb;
-}
+var mimeDb = require$$0;
 
-exports.requireMimeDb = requireMimeDb;
+export { mimeDb as m };

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.16.2",
+  "version": "0.17.1",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",

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

@@ -30,10 +30,16 @@ export interface ComplexType extends StrictOmit<DataType, 'own' | 'exportSchema'
     readonly ctor: Type;
     readonly base?: ComplexType | UnionType;
     readonly own: ComplexType.OwnProperties;
+    readonly abstract?: boolean;
+    readonly additionalFields?: boolean;
     exportSchema(): OpraSchema.ComplexType;
     addField(init: ApiField.InitArguments): ApiField;
-    getField(name: string): ApiField;
-    normalizeFieldNames(fields: string | string[]): string[] | undefined;
+    iteratePath(path: string, silent?: boolean): IterableIterator<[string, ApiField | undefined, string]>;
+    getField(nameOrPath: string): ApiField;
+    findField(nameOrPath: string): ApiField | undefined;
+    normalizeFieldPath(fields: string): string;
+    normalizeFieldPath(fields: string[]): string[];
+    normalizeFieldPath(fields: string | string[]): string | string[];
 }
 /**
  * Type definition of ComplexType constructor type

package/types/common/document/resource/collection.d.ts

@@ -44,9 +44,11 @@ export interface Collection extends StrictOmit<Resource, 'exportSchema' | '_cons
     readonly primaryKey: string[];
     exportSchema(): OpraSchema.Collection;
     parseKeyValue(value: any): any;
-    normalizeFieldNames(fields: string[]): string[] | undefined;
-    normalizeSortFields(fields: string[]): string[] | undefined;
-    normalizeFilterFields(ast: Expression): Expression;
+    normalizeFieldPath(fields: string): string;
+    normalizeFieldPath(fields: string[]): string[];
+    normalizeFieldPath(fields: string | string[]): string | string[];
+    normalizeSortFields(fields: string | string[]): string[];
+    normalizeFilter(ast: Expression): Expression;
     _construct(init: Collection.InitArguments): void;
 }
 export interface CollectionConstructor {

package/types/common/document/resource/singleton.d.ts

@@ -34,7 +34,9 @@ export interface Singleton extends StrictOmit<Resource, 'exportSchema' | '_const
     readonly operations: Singleton.Operations;
     readonly controller?: object | Type;
     exportSchema(): OpraSchema.Singleton;
-    normalizeFieldNames(fields: string[]): string[] | undefined;
+    normalizeFieldPath(fields: string): string;
+    normalizeFieldPath(fields: string[]): string[];
+    normalizeFieldPath(fields: string | string[]): string | string[];
     _construct(init: Singleton.InitArguments): void;
 }
 export interface SingletonConstructor {

package/types/common/filter/ast/terms/qualified-identifier.d.ts

@@ -1,4 +1,8 @@
+import type { ApiField } from '../../../document/data-type/api-field.js';
+import { DataType } from '../../../document/data-type/data-type.js';
 import { Literal } from '../abstract/literal.js';
 export declare class QualifiedIdentifier extends Literal {
+    dataType: DataType;
+    field?: ApiField;
     constructor(value: string);
 }

package/types/common/http/http-params.d.ts

@@ -7,7 +7,8 @@ import { IntegerCodec } from './codecs/integer-codec.js';
 import { NumberCodec } from './codecs/number-codec.js';
 import { StringCodec } from './codecs/string-codec.js';
 export declare namespace HttpParams {
-    type Initiator = string | URLSearchParams | HttpParams | Map<string, any> | Record<string, any>;
+    type Initiator = string | URLSearchParams | HttpParams | Map<string, HttpParams.Value> | Record<string, HttpParams.Value>;
+    type Value = string | number | boolean | object | null;
     interface Options {
         onChange?: () => void;
         params?: Record<string, ParamDefinition>;
@@ -16,8 +17,8 @@ export declare namespace HttpParams {
         codec?: Codec | string;
     };
     interface Codec {
-        decode(value: string): any;
-        encode(value: any): string;
+        decode(value: string): HttpParams.Value;
+        encode(value: HttpParams.Value): string;
     }
 }
 interface HttpParamMetadata {
@@ -36,7 +37,7 @@ export declare class HttpParams {
     protected static kSize: symbol;
     protected static kParamDefs: symbol;
     protected static kOptions: symbol;
-    protected [kEntries]: ResponsiveMap<any[]>;
+    protected [kEntries]: ResponsiveMap<HttpParams.Value[]>;
     protected [kSize]: number;
     protected [kOptions]: HttpParams.Options;
     protected [kParamDefs]: Map<string, HttpParamMetadata>;
@@ -46,27 +47,27 @@ export declare class HttpParams {
      * Appends a new value to the existing set of values for a parameter
      * and returns this instance
      */
-    append(name: string, value?: any): this;
+    append(name: string, value?: HttpParams.Value): this;
     appendAll(input: HttpParams.Initiator): this;
     changed(): void;
     clear(): void;
     /**
      * Deletes values for a given parameter
      */
-    delete(name: string, value?: any): this;
+    delete(name: string, value?: HttpParams.Value): this;
     /**
      * Returns an iterable of key, value pairs for every entry in the map.
      */
-    entries(): IterableIterator<[string, string]>;
-    forEach(callbackFn: (value: string, key: string, parent: HttpParams) => void, thisArg?: any): void;
+    entries(): IterableIterator<[string, HttpParams.Value]>;
+    forEach(callbackFn: (value: HttpParams.Value, key: string, parent: HttpParams) => void, thisArg?: any): void;
     /**
      * Retrieves value of a given parameter at given index
      */
-    get(name: string, index?: number): any;
+    get(name: string, index?: number): HttpParams.Value;
     /**
      * Retrieves an array of values for a given parameter.
      */
-    getAll(name: string): any[] | null;
+    getAll(name: string): HttpParams.Value[] | null;
     /**
      * Retrieves the names of the parameters.
      */
@@ -74,7 +75,7 @@ export declare class HttpParams {
     /**
      * Retrieves the names of the parameters.
      */
-    values(): IterableIterator<any>;
+    values(): IterableIterator<HttpParams.Value>;
     /**
      * Checks for existence of a parameter.
      */
@@ -83,23 +84,23 @@ export declare class HttpParams {
      * Sets or modifies a value for a given parameter.
      * If the header already exists, its value is replaced with the given value
      */
-    set(name: string, value: any): this;
+    set(name: string, value?: HttpParams.Value): this;
     sort(compareFn?: (a: string, b: string) => number): this;
     /**
      * Serializes the body to an encoded string, where key-value pairs (separated by `=`) are
      * separated by `&`s.
      */
     toString(): string;
-    getProxy(): Record<string, any>;
+    getProxy(): Record<string, HttpParams.Value>;
     define(params: Record<string, HttpParams.ParamDefinition>): this;
     define(name: string, options: HttpParams.ParamDefinition): this;
-    encodeValue(value: any, key: string): string;
-    decodeValue(value: string, key: string): any;
-    protected _append(name: string, value?: any): void;
-    protected _delete(name: string, value?: string | string[]): boolean;
-    protected _set(name: string, value: any, index?: number): void;
-    [Symbol.iterator](): IterableIterator<[string, string]>;
+    encodeValue(value: HttpParams.Value, key: string): string;
+    decodeValue(value: string, key: string): HttpParams.Value;
+    [Symbol.iterator](): IterableIterator<[string, HttpParams.Value]>;
     get [Symbol.toStringTag](): string;
+    protected _append(name: string, value?: HttpParams.Value): void;
+    protected _delete(name: string, value?: HttpParams.Value): boolean;
+    protected _set(name: string, value?: HttpParams.Value, index?: number): void;
     static codecs: {
         boolean: BooleanCodec;
         date: DateCodec;