tsoa

node_modules/@hapi/mimos/lib/index.d.ts

@@ -0,0 +1,134 @@
+// Declare our own interface to mime-db data
+
+declare namespace MimeDb {
+
+    type MimeSource = 'iana' | 'apache' | 'nginx';
+
+    interface MimeEntry {
+
+        /**
+         * String with identifier for the source of the data.
+         */
+        source?: MimeSource;
+
+        /**
+         * Array of strings with possible lowercased file extensions, without the
+         * dot.
+         */
+        extensions?: ReadonlyArray<string>;
+
+        /**
+         * Boolean that indicates if the contents is likely to become smaller if
+         * gzip or similar compression is applied.
+         */
+        compressible?: boolean;
+
+        /**
+         * Charset for type.
+         */
+        charset?: string;
+    }
+}
+
+
+// Helpers
+
+type NoInfer<T> = [T][T extends any ? 0 : never];
+
+
+export class MimosEntry {
+
+    /**
+     * String with the content-type.
+     */
+    type: string;
+
+    /**
+     * String with identifier for the source of the data.
+     */
+    source: MimeDb.MimeSource | 'mime-db' | 'mimos';
+
+    /**
+     * Array of strings with possible lowercased file extensions, without the
+     * dot.
+     */
+    extensions: ReadonlyArray<string>;
+
+    /**
+     * Boolean that indicates if the contents is likely to become smaller if
+     * gzip or similar compression is applied.
+     */
+    compressible: boolean;
+
+    /**
+     * Optional charset for type.
+     */
+    charset?: string;
+
+    private constructor();
+}
+
+export interface MimosDeclaration<P extends object = {}> extends MimeDb.MimeEntry {
+
+    /**
+     * The `type` value of result objects, defaults to `key`.
+     */
+    type?: string;
+
+    /**
+     * Method with signature `function(mime)`.
+     *
+     * When this mime type is found in the database, this function will run.
+     * This allows you make customizations to `mime` based on developer criteria.
+     */
+    predicate?: (mime: MimosEntry & P) => MimosEntry;
+}
+
+export interface MimosOptions<P extends object = {}> {
+
+    /**
+     * An object hash that is merged into the built-in mime information from
+     * {@link https://github.com/jshttp/mime-db}.
+     *
+     * Each key value pair represents a single mime object override.
+     *
+     * Each override entry should follow this schema:
+     *  * The key is the lower-cased correct mime-type. (Ex. "application/javascript").
+     *  * The value should be an object following the structure from
+     *    {@link https://github.com/jshttp/mime-db#data-structure} with additional
+     *    optional values:
+     *     * type - Specify the `type` value of result objects, defaults to `key`.
+     *     * predicate - Method that is called with mime entry on lookup, that
+     *       must return an entry. This allows you make customizations to `mime`
+     *       based on developer criteria.
+     */
+    override?: {
+        [type: string]: MimosDeclaration<P> & P;
+    };
+}
+
+export class Mimos<P extends object = {}> {
+
+    /**
+     * Create a Mimos object for mime lookups.
+     */
+    constructor(options?: MimosOptions<NoInfer<P>>);
+
+    /**
+     * Extract extension from file path and lookup mime information.
+     *
+     * @param path - Path to file
+     *
+     * @return Found mime object, or {} if no match.
+     */
+    path(path: string): (Readonly<MimosEntry & Partial<P>>) | {};
+
+    /**
+     * Lookup mime information.
+     *
+     * @param type - The content-type to find mime information about.
+     *
+     * @return Mime object for provided type.
+    */
+    type(type: string): Readonly<MimosEntry & Partial<P>>;
+}

node_modules/@hapi/mimos/lib/index.js

@@ -0,0 +1,147 @@
+'use strict';
+
+const Path = require('path');
+
+const Hoek = require('@hapi/hoek');
+const MimeDb = require('mime-db/db.json');          // Load JSON file to prevent loading or executing code
+
+
+const internals = {
+    compressibleRx: /^text\/|\+json$|\+text$|\+xml$/
+};
+
+
+exports.MimosEntry = class {
+
+    constructor(type, mime) {
+
+        this.type = type;
+        this.source = 'mime-db';
+        this.extensions = [];
+        this.compressible = undefined;
+
+        Object.assign(this, mime);
+
+        if (this.compressible === undefined) {
+            this.compressible = internals.compressibleRx.test(type);
+        }
+    }
+};
+
+
+internals.insertEntry = function (type, entry, db) {
+
+    db.byType.set(type, entry);
+    for (const ext of entry.extensions) {
+        db.byExtension.set(ext, entry);
+        if (ext.length > db.maxExtLength) {
+            db.maxExtLength = ext.length;
+        }
+    }
+};
+
+
+internals.compile = function (mimedb) {
+
+    const db = {
+        byType: new Map(),
+        byExtension: new Map(),
+        maxExtLength: 0
+    };
+
+    for (const type in mimedb) {
+        const entry = new exports.MimosEntry(type, mimedb[type]);
+        internals.insertEntry(type, entry, db);
+    }
+
+    return db;
+};
+
+
+internals.getTypePart = function (fulltype) {
+
+    const splitAt = fulltype.indexOf(';');
+    return splitAt === -1 ? fulltype : fulltype.slice(0, splitAt);
+};
+
+
+internals.applyPredicate = function (mime) {
+
+    if (mime.predicate) {
+        return mime.predicate(Hoek.clone(mime));
+    }
+
+    return mime;
+};
+
+
+exports.Mimos = class Mimos {
+
+    #db = internals.base;
+
+    constructor(options = {}) {
+
+        if (options.override) {
+            Hoek.assert(typeof options.override === 'object', 'overrides option must be an object');
+
+            // Shallow clone db
+
+            this.#db = {
+                ...this.#db,
+                byType: new Map(this.#db.byType),
+                byExtension: new Map(this.#db.byExtension)
+            };
+
+            // Apply overrides
+
+            for (const type in options.override) {
+                const override = options.override[type];
+                Hoek.assert(!override.predicate || typeof override.predicate === 'function', 'predicate option must be a function');
+
+                const from = this.#db.byType.get(type);
+                const baseEntry = from ? Hoek.applyToDefaults(from, override) : override;
+
+                const entry = new exports.MimosEntry(type, baseEntry);
+                internals.insertEntry(type, entry, this.#db);
+            }
+        }
+    }
+
+    path(path) {
+
+        const extension = Path.extname(path).slice(1).toLowerCase();
+        const mime = this.#db.byExtension.get(extension) ?? {};
+
+        return internals.applyPredicate(mime);
+    }
+
+    type(type) {
+
+        type = internals.getTypePart(type);
+
+        let mime = this.#db.byType.get(type);
+        if (!mime) {
+            // Retry with more expensive adaptations
+
+            type = type.trim().toLowerCase();
+            mime = this.#db.byType.get(type);
+        }
+
+        if (!mime) {
+            mime = new exports.MimosEntry(type, {
+                source: 'mimos'
+            });
+
+            // Cache the entry
+
+            internals.insertEntry(type, mime, this.#db);
+
+            return mime;
+        }
+
+        return internals.applyPredicate(mime);
+    }
+};
+
+
+internals.base = internals.compile(MimeDb);