@opra/client 0.15.0 → 0.16.1

package/esm/{mime-db-d0f15d8f.js → mime-db-95975a69.js}

@@ -10708,10 +10708,18 @@ var require$$0 = {
  * MIT Licensed
  */
 
-/**
- * Module exports.
- */
+var mimeDb;
+var hasRequiredMimeDb;
+
+function requireMimeDb () {
+	if (hasRequiredMimeDb) return mimeDb;
+	hasRequiredMimeDb = 1;
+	/**
+	 * Module exports.
+	 */
 
-var mimeDb = require$$0;
+	mimeDb = require$$0;
+	return mimeDb;
+}
 
-export { mimeDb as m };
+export { requireMimeDb as r };

package/esm/mime-types-f653a5df.js

@@ -0,0 +1,203 @@
+import { r as requireMimeDb } from './mime-db-95975a69.js';
+import require$$4 from 'path-browserify';
+
+var mimeTypes = {};
+
+/*!
+ * mime-types
+ * Copyright(c) 2014 Jonathan Ong
+ * Copyright(c) 2015 Douglas Christopher Wilson
+ * MIT Licensed
+ */
+
+var hasRequiredMimeTypes;
+
+function requireMimeTypes () {
+	if (hasRequiredMimeTypes) return mimeTypes;
+	hasRequiredMimeTypes = 1;
+	(function (exports) {
+
+		/**
+		 * Module dependencies.
+		 * @private
+		 */
+
+		var db = requireMimeDb();
+		var extname = require$$4.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));
+	return mimeTypes;
+}
+
+export { requireMimeTypes as r };

package/esm/safe-buffer-9b74695b.js

@@ -0,0 +1,81 @@
+import require$$0 from 'buffer';
+
+var safeBuffer = {exports: {}};
+
+/*! safe-buffer. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+
+var hasRequiredSafeBuffer;
+
+function requireSafeBuffer () {
+	if (hasRequiredSafeBuffer) return safeBuffer.exports;
+	hasRequiredSafeBuffer = 1;
+	(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));
+	return safeBuffer.exports;
+}
+
+export { requireSafeBuffer as r };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opra/client",
-  "version": "0.15.0",
+  "version": "0.16.1",
   "description": "Opra Client package",
   "author": "Panates",
   "license": "MIT",
@@ -12,8 +12,8 @@
   "type": "module",
   "module": "./esm/index.min.mjs",
   "main": "./cjs/index.min.cjs",
-  "types": "./typings/index.d.ts",
-  "typings": "./typings/index.d.ts",
+  "types": "./types/index.d.ts",
+  "typings": "./types/index.d.ts",
   "exports": {
     "./package.json": {
       "default": "./package.json"
@@ -33,8 +33,8 @@
     "@browsery/util": "^0.2.0",
     "accepts": "^1.3.8",
     "buffer": "^6.0.3",
-    "crypto-browserify": "^3.12.0",
     "cookie": "^0.5.0",
+    "crypto-browserify": "^3.12.0",
     "dayjs": "^1.11.7",
     "encodeurl": "^1.0.2",
     "events": "^3.3.0",
@@ -47,7 +47,7 @@
     "putil-promisify": "^1.10.0",
     "putil-varhelpers": "^1.6.5",
     "reflect-metadata": "^0.1.13",
-    "rxjs": "^7.8.0",
+    "rxjs": "^7.8.1",
     "ts-lib": "^0.0.5",
     "type-is": "^1.6.18",
     "uid": "^2.0.1"
@@ -55,10 +55,9 @@
   "devDependencies": {},
   "sideEffects": false,
   "files": [
-    "typings/",
     "cjs/",
     "esm/",
-    "typings/",
+    "types/",
     "LICENSE",
     "README.md"
   ],

package/{typings → types}/common/document/factory/import-resource-class.d.ts

@@ -1,3 +1,4 @@
+import 'reflect-metadata';
 import { Type } from 'ts-gems';
 import { OpraSchema } from '../../schema/index.js';
 import type { ThunkAsync } from '../../types.js';

package/{typings → types}/common/document/resource/collection.d.ts

@@ -22,19 +22,19 @@ export declare namespace Collection {
     export interface Operations {
         create?: OpraSchema.Collection.CreateOperation & Operation;
         delete?: OpraSchema.Collection.DeleteOperation & Operation;
-        deleteMany?: OpraSchema.Collection.DeleteManyOperation & Operation;
         get?: OpraSchema.Collection.GetOperation & Operation;
         update?: OpraSchema.Collection.UpdateOperation & Operation;
+        deleteMany?: OpraSchema.Collection.DeleteManyOperation & Operation;
+        findMany?: OpraSchema.Collection.FindManyOperation & Operation;
         updateMany?: OpraSchema.Collection.UpdateManyOperation & Operation;
-        search?: OpraSchema.Collection.SearchOperation & Operation;
     }
     export type CreateOperationOptions = StrictOmit<OpraSchema.Collection.CreateOperation, 'handler'>;
     export type DeleteOperationOptions = StrictOmit<OpraSchema.Collection.DeleteOperation, 'handler'>;
     export type DeleteManyOperationOptions = StrictOmit<OpraSchema.Collection.DeleteManyOperation, 'handler'>;
+    export type FindManyOperationOptions = StrictOmit<OpraSchema.Collection.FindManyOperation, 'handler'>;
     export type GetOperationOptions = StrictOmit<OpraSchema.Collection.GetOperation, 'handler'>;
     export type UpdateOperationOptions = StrictOmit<OpraSchema.Collection.UpdateOperation, 'handler'>;
     export type UpdateManyOperationOptions = StrictOmit<OpraSchema.Collection.UpdateManyOperation, 'handler'>;
-    export type SearchOperationOptions = StrictOmit<OpraSchema.Collection.SearchOperation, 'handler'>;
     export {};
 }
 export interface Collection extends StrictOmit<Resource, 'exportSchema' | '_construct'> {
@@ -53,13 +53,13 @@ export interface CollectionConstructor {
     prototype: Collection;
     new (document: ApiDocument, init: Collection.InitArguments): Collection;
     (type: TypeThunkAsync | string, options?: Collection.DecoratorOptions): ClassDecorator;
-    CreateOperation: (options?: Collection.CreateOperationOptions) => PropertyDecorator;
-    GetOperation: (options?: Collection.GetOperationOptions) => PropertyDecorator;
-    DeleteOperation: (options?: Collection.DeleteOperationOptions) => PropertyDecorator;
-    UpdateOperation: (options?: Collection.UpdateOperationOptions) => PropertyDecorator;
-    SearchOperation: (options?: Collection.SearchOperationOptions) => PropertyDecorator;
-    UpdateManyOperation: (options?: Collection.UpdateManyOperationOptions) => PropertyDecorator;
-    DeleteManyOperation: (options?: Collection.DeleteManyOperationOptions) => PropertyDecorator;
+    Create: (options?: Collection.CreateOperationOptions) => PropertyDecorator;
+    Delete: (options?: Collection.DeleteOperationOptions) => PropertyDecorator;
+    Get: (options?: Collection.GetOperationOptions) => PropertyDecorator;
+    Update: (options?: Collection.UpdateOperationOptions) => PropertyDecorator;
+    FindMany: (options?: Collection.FindManyOperationOptions) => PropertyDecorator;
+    DeleteMany: (options?: Collection.DeleteManyOperationOptions) => PropertyDecorator;
+    UpdateMany: (options?: Collection.UpdateManyOperationOptions) => PropertyDecorator;
 }
 /**
  *

package/{typings → types}/common/document/resource/singleton.d.ts

@@ -41,9 +41,9 @@ export interface SingletonConstructor {
     prototype: Singleton;
     new (document: ApiDocument, init: Singleton.InitArguments): Singleton;
     (type: TypeThunkAsync | string, options?: Singleton.DecoratorOptions): ClassDecorator;
-    CreateOperation: (options?: Singleton.CreateOperationOptions) => PropertyDecorator;
-    GetOperation: (options?: Singleton.GetOperationOptions) => PropertyDecorator;
-    DeleteOperation: (options?: Singleton.DeleteOperationOptions) => PropertyDecorator;
-    UpdateOperation: (options?: Singleton.UpdateOperationOptions) => PropertyDecorator;
+    Create: (options?: Singleton.CreateOperationOptions) => PropertyDecorator;
+    Delete: (options?: Singleton.DeleteOperationOptions) => PropertyDecorator;
+    Get: (options?: Singleton.GetOperationOptions) => PropertyDecorator;
+    Update: (options?: Singleton.UpdateOperationOptions) => PropertyDecorator;
 }
 export declare const Singleton: SingletonConstructor;

package/{typings → types}/common/schema/resource/collection.interface.d.ts

@@ -12,22 +12,22 @@ export declare namespace Collection {
     const Kind = "Collection";
     type Kind = 'Collection';
     type CreateOperation = Endpoint & _Operation.InputPickOmit & _Operation.ResponsePickOmit;
-    type GetOperation = Endpoint & _Operation.ResponsePickOmit;
     type DeleteOperation = Endpoint;
     type DeleteManyOperation = Endpoint & _Operation.Filter;
-    type UpdateOperation = Endpoint & _Operation.InputPickOmit & _Operation.ResponsePickOmit;
-    type UpdateManyOperation = Endpoint & _Operation.InputPickOmit & _Operation.Filter;
-    type SearchOperation = Endpoint & _Operation.Filter & _Operation.ResponsePickOmit & {
+    type GetOperation = Endpoint & _Operation.ResponsePickOmit;
+    type FindManyOperation = Endpoint & _Operation.Filter & _Operation.ResponsePickOmit & {
         sortFields?: string[];
         defaultSort?: string[];
     };
+    type UpdateOperation = Endpoint & _Operation.InputPickOmit & _Operation.ResponsePickOmit;
+    type UpdateManyOperation = Endpoint & _Operation.InputPickOmit & _Operation.Filter;
     interface Operations {
         create?: CreateOperation;
         delete?: DeleteOperation;
-        deleteMany?: DeleteManyOperation;
         get?: GetOperation;
         update?: UpdateOperation;
+        deleteMany?: DeleteManyOperation;
+        findMany?: FindManyOperation;
         updateMany?: UpdateManyOperation;
-        search?: SearchOperation;
     }
 }

package/{typings → types}/common/url/opra-url.d.ts

@@ -4,13 +4,13 @@ import { OpraURLPathComponentInit } from './opra-url-path-component.js';
 declare const nodeInspectCustom: unique symbol;
 declare const kContext: unique symbol;
 declare const kPath: unique symbol;
-declare const kSearchParams: unique symbol;
+declare const kParams: unique symbol;
 export declare class OpraURL {
     protected static kContext: symbol;
     protected static kPath: symbol;
-    protected static kSearchParams: symbol;
+    protected static kParams: symbol;
     protected [kPath]: OpraURLPath;
-    protected [kSearchParams]: HttpParams;
+    protected [kParams]: HttpParams;
     protected [kContext]: {
         protocol: string;
         username: string;

package/{typings → types}/http/http-client.d.ts

@@ -10,7 +10,7 @@ export interface OpraHttpClientOptions {
     /**
      //    * Opra Service Metadata Document
      //    */
-    document?: ApiDocument;
+    api?: ApiDocument;
     /**
      *
      */
@@ -23,7 +23,7 @@ export declare class OpraHttpClient {
     protected static kAssets: symbol;
     protected [kAssets]: {
         serviceUrl: string;
-        document?: ApiDocument;
+        api?: ApiDocument;
         metadataPromise?: Promise<any>;
         requestInterceptors: RequestInterceptor[];
         responseInterceptors: ResponseInterceptor[];

package/{typings → types}/http/http-collection-node.d.ts

@@ -21,7 +21,7 @@ export declare namespace HttpCollectionNode {
         omit?: string[];
         include?: string[];
     }
-    interface SearchOptions extends HttpRequestObservable.Options {
+    interface FindManyOptions extends HttpRequestObservable.Options {
         pick?: string[];
         omit?: string[];
         include?: string[];
@@ -86,13 +86,13 @@ export declare class HttpCollectionNode<TType, TResponseExt = any> {
     get(id: any, options?: StrictOmit<HttpCollectionNode.GetOptions, 'observe'> & {
         observe: 'events';
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
-    search(options?: StrictOmit<HttpCollectionNode.SearchOptions, 'observe'> & {
+    findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
         observe?: 'body';
     }): HttpRequestObservable<TType[], TType, TResponseExt>;
-    search(options?: StrictOmit<HttpCollectionNode.SearchOptions, 'observe'> & {
+    findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
         observe: 'response';
     }): HttpRequestObservable<HttpResponse<TType[]>, TType, TResponseExt>;
-    search(options?: StrictOmit<HttpCollectionNode.SearchOptions, 'observe'> & {
+    findMany(options?: StrictOmit<HttpCollectionNode.FindManyOptions, 'observe'> & {
         observe: 'events';
     }): HttpRequestObservable<HttpEvent, TType, TResponseExt>;
     update(id: any, data: PartialInput<TType>, options?: StrictOmit<HttpCollectionNode.UpdateOptions, 'observe'> & {