@metamask/snaps-controllers 1.0.2 → 2.0.1

package/dist/cjs/snaps/endowments/web-assembly.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "webAssemblyEndowmentBuilder", {
+    enumerable: true,
+    get: function() {
+        return webAssemblyEndowmentBuilder;
+    }
+});
+const _permissioncontroller = require("@metamask/permission-controller");
+const _enum = require("./enum");
+const permissionName = _enum.SnapEndowments.WebAssemblyAccess;
+/**
+ * `endowment:webassembly` returns the name of global browser API(s) that
+ * enable access to the WebAssembly API.
+ * This is intended to populate the endowments of the SES Compartment
+ * in which a Snap executes.
+ *
+ * @param _builderOptions - Optional specification builder options.
+ * @returns The specification for the WebAssembly endowment.
+ */ const specificationBuilder = (_builderOptions)=>{
+    return {
+        permissionType: _permissioncontroller.PermissionType.Endowment,
+        targetName: permissionName,
+        allowedCaveats: null,
+        endowmentGetter: (_getterOptions)=>{
+            return [
+                'WebAssembly'
+            ];
+        },
+        subjectTypes: [
+            _permissioncontroller.SubjectType.Snap
+        ]
+    };
+};
+const webAssemblyEndowmentBuilder = Object.freeze({
+    targetName: permissionName,
+    specificationBuilder
+});
+
+//# sourceMappingURL=web-assembly.js.map

package/dist/cjs/snaps/endowments/web-assembly.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/snaps/endowments/web-assembly.ts"],"sourcesContent":["import type {\n  EndowmentGetterParams,\n  PermissionSpecificationBuilder,\n  ValidPermissionSpecification,\n} from '@metamask/permission-controller';\nimport { PermissionType, SubjectType } from '@metamask/permission-controller';\n\nimport { SnapEndowments } from './enum';\n\nconst permissionName = SnapEndowments.WebAssemblyAccess;\n\ntype WebAssemblyEndowmentSpecification = ValidPermissionSpecification<{\n  permissionType: PermissionType.Endowment;\n  targetName: typeof permissionName;\n  endowmentGetter: (_options?: any) => ['WebAssembly'];\n  allowedCaveats: null;\n}>;\n\n/**\n * `endowment:webassembly` returns the name of global browser API(s) that\n * enable access to the WebAssembly API.\n * This is intended to populate the endowments of the SES Compartment\n * in which a Snap executes.\n *\n * @param _builderOptions - Optional specification builder options.\n * @returns The specification for the WebAssembly endowment.\n */\nconst specificationBuilder: PermissionSpecificationBuilder<\n  PermissionType.Endowment,\n  any,\n  WebAssemblyEndowmentSpecification\n> = (_builderOptions?: any) => {\n  return {\n    permissionType: PermissionType.Endowment,\n    targetName: permissionName,\n    allowedCaveats: null,\n    endowmentGetter: (_getterOptions?: EndowmentGetterParams) => {\n      return ['WebAssembly'];\n    },\n    subjectTypes: [SubjectType.Snap],\n  };\n};\n\nexport const webAssemblyEndowmentBuilder = Object.freeze({\n  targetName: permissionName,\n  specificationBuilder,\n} as const);\n"],"names":["webAssemblyEndowmentBuilder","permissionName","SnapEndowments","WebAssemblyAccess","specificationBuilder","_builderOptions","permissionType","PermissionType","Endowment","targetName","allowedCaveats","endowmentGetter","_getterOptions","subjectTypes","SubjectType","Snap","Object","freeze"],"mappings":";;;;+BA2CaA;;;eAAAA;;;sCAtC+B;sBAEb;AAE/B,MAAMC,iBAAiBC,oBAAc,CAACC,iBAAiB;AASvD;;;;;;;;CAQC,GACD,MAAMC,uBAIF,CAACC;IACH,OAAO;QACLC,gBAAgBC,oCAAc,CAACC,SAAS;QACxCC,YAAYR;QACZS,gBAAgB;QAChBC,iBAAiB,CAACC;YAChB,OAAO;gBAAC;aAAc;QACxB;QACAC,cAAc;YAACC,iCAAW,CAACC,IAAI;SAAC;IAClC;AACF;AAEO,MAAMf,8BAA8BgB,OAAOC,MAAM,CAAC;IACvDR,YAAYR;IACZG;AACF"}

package/dist/cjs/snaps/index.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./location"), exports);
+_export_star(require("./SnapController"), exports);
+_export_star(require("./endowments"), exports);
+_export_star(require("./selectors"), exports);
+_export_star(require("./registry"), exports);
+_export_star(require("./permissions"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/snaps/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/snaps/index.ts"],"sourcesContent":["export * from './location';\nexport * from './SnapController';\nexport * from './endowments';\nexport * from './selectors';\nexport * from './registry';\nexport * from './permissions';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA;qBACA;qBACA"}

package/dist/cjs/snaps/location/http.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "HttpLocation", {
+    enumerable: true,
+    get: function() {
+        return HttpLocation;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+function _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+class HttpLocation {
+    async manifest() {
+        if (this.validatedManifest) {
+            return this.validatedManifest.clone();
+        }
+        // jest-fetch-mock doesn't handle new URL(), we need to convert .toString()
+        const canonicalPath = new URL(_snapsutils.NpmSnapFileNames.Manifest, this.url).toString();
+        const response = await this.fetchFn(canonicalPath, this.fetchOptions);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch "${canonicalPath}". Status code: ${response.status}.`);
+        }
+        const contents = await response.text();
+        const manifest = (0, _snapsutils.parseJson)(contents);
+        const vfile = new _snapsutils.VirtualFile({
+            value: contents,
+            result: (0, _snapsutils.createSnapManifest)(manifest),
+            path: _snapsutils.NpmSnapFileNames.Manifest,
+            data: {
+                canonicalPath
+            }
+        });
+        this.validatedManifest = vfile;
+        return this.manifest();
+    }
+    async fetch(path) {
+        const relativePath = (0, _snapsutils.normalizeRelative)(path);
+        const cached = this.cache.get(relativePath);
+        if (cached !== undefined) {
+            const { file, contents } = cached;
+            const value = new Uint8Array(await contents.arrayBuffer());
+            const vfile = file.clone();
+            vfile.value = value;
+            return vfile;
+        }
+        const canonicalPath = this.toCanonical(relativePath).toString();
+        const response = await this.fetchFn(canonicalPath, this.fetchOptions);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch "${canonicalPath}". Status code: ${response.status}.`);
+        }
+        const vfile = new _snapsutils.VirtualFile({
+            value: '',
+            path: relativePath,
+            data: {
+                canonicalPath
+            }
+        });
+        const blob = await response.blob();
+        (0, _utils.assert)(!this.cache.has(relativePath), 'Corrupted cache, multiple files with same path.');
+        this.cache.set(relativePath, {
+            file: vfile,
+            contents: blob
+        });
+        return this.fetch(relativePath);
+    }
+    get root() {
+        return new URL(this.url);
+    }
+    toCanonical(path) {
+        (0, _utils.assert)(!path.startsWith('/'), 'Tried to parse absolute path.');
+        return new URL(path, this.url);
+    }
+    constructor(url, opts = {}){
+        // We keep contents separate because then we can use only one Blob in cache,
+        // which we convert to Uint8Array when actually returning the file.
+        //
+        // That avoids deepCloning file contents.
+        // I imagine ArrayBuffers are copy-on-write optimized, meaning
+        // in most often case we'll only have one file contents in common case.
+        _define_property(this, "cache", new Map());
+        _define_property(this, "validatedManifest", void 0);
+        _define_property(this, "url", void 0);
+        _define_property(this, "fetchFn", void 0);
+        _define_property(this, "fetchOptions", void 0);
+        (0, _utils.assertStruct)(url.toString(), _snapsutils.HttpSnapIdStruct, 'Invalid Snap Id: ');
+        this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
+        this.fetchOptions = opts.fetchOptions;
+        this.url = url;
+    }
+}
+
+//# sourceMappingURL=http.js.map

package/dist/cjs/snaps/location/http.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/snaps/location/http.ts"],"sourcesContent":["import type { SnapManifest } from '@metamask/snaps-utils';\nimport {\n  VirtualFile,\n  HttpSnapIdStruct,\n  NpmSnapFileNames,\n  createSnapManifest,\n  normalizeRelative,\n  parseJson,\n} from '@metamask/snaps-utils';\nimport { assert, assertStruct } from '@metamask/utils';\n\nimport type { SnapLocation } from './location';\n\nexport interface HttpOptions {\n  /**\n   * @default fetch\n   */\n  fetch?: typeof fetch;\n  fetchOptions?: RequestInit;\n}\n\nexport class HttpLocation implements SnapLocation {\n  // We keep contents separate because then we can use only one Blob in cache,\n  // which we convert to Uint8Array when actually returning the file.\n  //\n  // That avoids deepCloning file contents.\n  // I imagine ArrayBuffers are copy-on-write optimized, meaning\n  // in most often case we'll only have one file contents in common case.\n  private readonly cache = new Map<\n    string,\n    { file: VirtualFile; contents: Blob }\n  >();\n\n  private validatedManifest?: VirtualFile<SnapManifest>;\n\n  private readonly url: URL;\n\n  private readonly fetchFn: typeof fetch;\n\n  private readonly fetchOptions?: RequestInit;\n\n  constructor(url: URL, opts: HttpOptions = {}) {\n    assertStruct(url.toString(), HttpSnapIdStruct, 'Invalid Snap Id: ');\n    this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);\n    this.fetchOptions = opts.fetchOptions;\n    this.url = url;\n  }\n\n  async manifest(): Promise<VirtualFile<SnapManifest>> {\n    if (this.validatedManifest) {\n      return this.validatedManifest.clone();\n    }\n\n    // jest-fetch-mock doesn't handle new URL(), we need to convert .toString()\n    const canonicalPath = new URL(\n      NpmSnapFileNames.Manifest,\n      this.url,\n    ).toString();\n\n    const response = await this.fetchFn(canonicalPath, this.fetchOptions);\n    if (!response.ok) {\n      throw new Error(\n        `Failed to fetch \"${canonicalPath}\". Status code: ${response.status}.`,\n      );\n    }\n    const contents = await response.text();\n    const manifest = parseJson(contents);\n    const vfile = new VirtualFile<SnapManifest>({\n      value: contents,\n      result: createSnapManifest(manifest),\n      path: NpmSnapFileNames.Manifest,\n      data: { canonicalPath },\n    });\n    this.validatedManifest = vfile;\n\n    return this.manifest();\n  }\n\n  async fetch(path: string): Promise<VirtualFile> {\n    const relativePath = normalizeRelative(path);\n    const cached = this.cache.get(relativePath);\n    if (cached !== undefined) {\n      const { file, contents } = cached;\n      const value = new Uint8Array(await contents.arrayBuffer());\n      const vfile = file.clone();\n      vfile.value = value;\n      return vfile;\n    }\n\n    const canonicalPath = this.toCanonical(relativePath).toString();\n    const response = await this.fetchFn(canonicalPath, this.fetchOptions);\n    if (!response.ok) {\n      throw new Error(\n        `Failed to fetch \"${canonicalPath}\". Status code: ${response.status}.`,\n      );\n    }\n    const vfile = new VirtualFile({\n      value: '',\n      path: relativePath,\n      data: { canonicalPath },\n    });\n    const blob = await response.blob();\n    assert(\n      !this.cache.has(relativePath),\n      'Corrupted cache, multiple files with same path.',\n    );\n    this.cache.set(relativePath, { file: vfile, contents: blob });\n\n    return this.fetch(relativePath);\n  }\n\n  get root(): URL {\n    return new URL(this.url);\n  }\n\n  private toCanonical(path: string): URL {\n    assert(!path.startsWith('/'), 'Tried to parse absolute path.');\n    return new URL(path, this.url);\n  }\n}\n"],"names":["HttpLocation","manifest","validatedManifest","clone","canonicalPath","URL","NpmSnapFileNames","Manifest","url","toString","response","fetchFn","fetchOptions","ok","Error","status","contents","text","parseJson","vfile","VirtualFile","value","result","createSnapManifest","path","data","fetch","relativePath","normalizeRelative","cached","cache","get","undefined","file","Uint8Array","arrayBuffer","toCanonical","blob","assert","has","set","root","startsWith","constructor","opts","Map","assertStruct","HttpSnapIdStruct","globalThis","bind"],"mappings":"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"}

package/dist/cjs/snaps/location/index.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./location"), exports);
+_export_star(require("./npm"), exports);
+_export_star(require("./local"), exports);
+_export_star(require("./http"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}
+
+//# sourceMappingURL=index.js.map

package/dist/cjs/snaps/location/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/snaps/location/index.ts"],"sourcesContent":["export * from './location';\nexport * from './npm';\nexport * from './local';\nexport * from './http';\n"],"names":[],"mappings":";;;;qBAAc;qBACA;qBACA;qBACA"}

package/dist/cjs/snaps/location/local.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "LocalLocation", {
+    enumerable: true,
+    get: function() {
+        return LocalLocation;
+    }
+});
+const _snapsutils = require("@metamask/snaps-utils");
+const _utils = require("@metamask/utils");
+const _http = require("./http");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) {
+        return descriptor.get.call(receiver);
+    }
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) {
+        descriptor.set.call(receiver, value);
+    } else {
+        if (!descriptor.writable) {
+            throw new TypeError("attempted to set read only private field");
+        }
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) {
+        throw new TypeError("attempted to " + action + " private field on non-instance");
+    }
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+var _http1 = /*#__PURE__*/ new WeakMap();
+class LocalLocation {
+    async manifest() {
+        const vfile = await _class_private_field_get(this, _http1).manifest();
+        return convertCanonical(vfile);
+    }
+    async fetch(path) {
+        return convertCanonical(await _class_private_field_get(this, _http1).fetch(path));
+    }
+    get shouldAlwaysReload() {
+        return true;
+    }
+    constructor(url, opts = {}){
+        _class_private_field_init(this, _http1, {
+            writable: true,
+            value: void 0
+        });
+        (0, _utils.assertStruct)(url.toString(), _snapsutils.LocalSnapIdStruct, 'Invalid Snap Id');
+        // TODO(ritave): Write deepMerge() which merges fetchOptions.
+        (0, _utils.assert)(opts.fetchOptions === undefined, 'Currently adding fetch options to local: is unsupported.');
+        _class_private_field_set(this, _http1, new _http.HttpLocation(new URL(url.toString().slice(_snapsutils.SnapIdPrefixes.local.length)), {
+            ...opts,
+            fetchOptions: {
+                cache: 'no-cache'
+            }
+        }));
+    }
+}
+/**
+ * Converts vfiles with canonical `http:` paths into `local:` paths.
+ *
+ * @param vfile - The {@link VirtualFile} to convert.
+ * @returns The same object with updated `.data.canonicalPath`.
+ */ function convertCanonical(vfile) {
+    (0, _utils.assert)(vfile.data.canonicalPath !== undefined);
+    vfile.data.canonicalPath = `local:${vfile.data.canonicalPath}`;
+    return vfile;
+}
+
+//# sourceMappingURL=local.js.map

package/dist/cjs/snaps/location/local.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/snaps/location/local.ts"],"sourcesContent":["import type { SnapManifest, VirtualFile } from '@metamask/snaps-utils';\nimport { LocalSnapIdStruct, SnapIdPrefixes } from '@metamask/snaps-utils';\nimport { assert, assertStruct } from '@metamask/utils';\n\nimport type { HttpOptions } from './http';\nimport { HttpLocation } from './http';\nimport type { SnapLocation } from './location';\n\nexport class LocalLocation implements SnapLocation {\n  readonly #http: HttpLocation;\n\n  constructor(url: URL, opts: HttpOptions = {}) {\n    assertStruct(url.toString(), LocalSnapIdStruct, 'Invalid Snap Id');\n    // TODO(ritave): Write deepMerge() which merges fetchOptions.\n    assert(\n      opts.fetchOptions === undefined,\n      'Currently adding fetch options to local: is unsupported.',\n    );\n\n    this.#http = new HttpLocation(\n      new URL(url.toString().slice(SnapIdPrefixes.local.length)),\n      { ...opts, fetchOptions: { cache: 'no-cache' } },\n    );\n  }\n\n  async manifest(): Promise<VirtualFile<SnapManifest>> {\n    const vfile = await this.#http.manifest();\n\n    return convertCanonical(vfile);\n  }\n\n  async fetch(path: string): Promise<VirtualFile> {\n    return convertCanonical(await this.#http.fetch(path));\n  }\n\n  get shouldAlwaysReload() {\n    return true;\n  }\n}\n\n/**\n * Converts vfiles with canonical `http:` paths into `local:` paths.\n *\n * @param vfile - The {@link VirtualFile} to convert.\n * @returns The same object with updated `.data.canonicalPath`.\n */\nfunction convertCanonical<Result>(\n  vfile: VirtualFile<Result>,\n): VirtualFile<Result> {\n  assert(vfile.data.canonicalPath !== undefined);\n  vfile.data.canonicalPath = `local:${vfile.data.canonicalPath}`;\n  return vfile;\n}\n"],"names":["LocalLocation","manifest","vfile","http","convertCanonical","fetch","path","shouldAlwaysReload","constructor","url","opts","assertStruct","toString","LocalSnapIdStruct","assert","fetchOptions","undefined","HttpLocation","URL","slice","SnapIdPrefixes","local","length","cache","data","canonicalPath"],"mappings":";;;;+BAQaA;;;eAAAA;;;4BAPqC;uBACb;sBAGR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIlB;AADJ,MAAMA;IAiBX,MAAMC,WAA+C;QACnD,MAAMC,QAAQ,MAAM,yBAAA,IAAI,EAAEC,QAAKF,QAAQ;QAEvC,OAAOG,iBAAiBF;IAC1B;IAEA,MAAMG,MAAMC,IAAY,EAAwB;QAC9C,OAAOF,iBAAiB,MAAM,yBAAA,IAAI,EAAED,QAAKE,KAAK,CAACC;IACjD;IAEA,IAAIC,qBAAqB;QACvB,OAAO;IACT;IA1BAC,YAAYC,GAAQ,EAAEC,OAAoB,CAAC,CAAC,CAAE;QAF9C,gCAAS;;mBAAT,KAAA;;QAGEC,IAAAA,mBAAY,EAACF,IAAIG,QAAQ,IAAIC,6BAAiB,EAAE;QAChD,6DAA6D;QAC7DC,IAAAA,aAAM,EACJJ,KAAKK,YAAY,KAAKC,WACtB;uCAGIb,QAAO,IAAIc,kBAAY,CAC3B,IAAIC,IAAIT,IAAIG,QAAQ,GAAGO,KAAK,CAACC,0BAAc,CAACC,KAAK,CAACC,MAAM,IACxD;YAAE,GAAGZ,IAAI;YAAEK,cAAc;gBAAEQ,OAAO;YAAW;QAAE;IAEnD;AAeF;AAEA;;;;;CAKC,GACD,SAASnB,iBACPF,KAA0B;IAE1BY,IAAAA,aAAM,EAACZ,MAAMsB,IAAI,CAACC,aAAa,KAAKT;IACpCd,MAAMsB,IAAI,CAACC,aAAa,GAAG,CAAC,MAAM,EAAEvB,MAAMsB,IAAI,CAACC,aAAa,CAAC,CAAC;IAC9D,OAAOvB;AACT"}

package/dist/cjs/snaps/location/location.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "detectSnapLocation", {
+    enumerable: true,
+    get: function() {
+        return detectSnapLocation;
+    }
+});
+const _utils = require("@metamask/utils");
+const _http = require("./http");
+const _local = require("./local");
+const _npm = require("./npm");
+function detectSnapLocation(location, opts) {
+    const allowHttp = opts?.allowHttp ?? false;
+    const allowLocal = opts?.allowLocal ?? false;
+    const root = new URL(location);
+    switch(root.protocol){
+        case 'npm:':
+            return new _npm.NpmLocation(root, opts);
+        case 'local:':
+            (0, _utils.assert)(allowLocal, new TypeError('Fetching local snaps is disabled.'));
+            return new _local.LocalLocation(root, opts);
+        case 'http:':
+        case 'https:':
+            (0, _utils.assert)(allowHttp, new TypeError('Fetching snaps through http/https is disabled.'));
+            return new _http.HttpLocation(root, opts);
+        default:
+            throw new TypeError(`Unrecognized "${root.protocol}" snap location protocol.`);
+    }
+}
+
+//# sourceMappingURL=location.js.map

package/dist/cjs/snaps/location/location.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/snaps/location/location.ts"],"sourcesContent":["import type { SnapManifest, VirtualFile } from '@metamask/snaps-utils';\nimport { assert } from '@metamask/utils';\n\nimport { HttpLocation } from './http';\nimport { LocalLocation } from './local';\nimport type { NpmOptions } from './npm';\nimport { NpmLocation } from './npm';\n\ndeclare module '@metamask/snaps-utils' {\n  interface DataMap {\n    /**\n     * Fully qualified, canonical path for the file in {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8 } URI format.\n     */\n    canonicalPath: string;\n  }\n}\n\nexport interface SnapLocation {\n  /**\n   * All files are relative to the manifest, except the manifest itself.\n   */\n  manifest(): Promise<VirtualFile<SnapManifest>>;\n  fetch(path: string): Promise<VirtualFile>;\n\n  readonly shouldAlwaysReload?: boolean;\n}\n\nexport type DetectSnapLocationOptions = NpmOptions & {\n  /**\n   * The function used to fetch data.\n   *\n   * @default globalThis.fetch\n   */\n  fetch?: typeof fetch;\n  /**\n   * @default false\n   */\n  allowHttp?: boolean;\n  /**\n   * @default false\n   */\n  allowLocal?: boolean;\n};\n\n/**\n * Auto-magically detects which SnapLocation object to create based on the provided {@link location}.\n *\n * @param location - A {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8} uri.\n * @param opts - NPM options and feature flags.\n * @returns SnapLocation based on url.\n */\nexport function detectSnapLocation(\n  location: string | URL,\n  opts?: DetectSnapLocationOptions,\n): SnapLocation {\n  const allowHttp = opts?.allowHttp ?? false;\n  const allowLocal = opts?.allowLocal ?? false;\n  const root = new URL(location);\n  switch (root.protocol) {\n    case 'npm:':\n      return new NpmLocation(root, opts);\n    case 'local:':\n      assert(allowLocal, new TypeError('Fetching local snaps is disabled.'));\n      return new LocalLocation(root, opts);\n    case 'http:':\n    case 'https:':\n      assert(\n        allowHttp,\n        new TypeError('Fetching snaps through http/https is disabled.'),\n      );\n      return new HttpLocation(root, opts);\n    default:\n      throw new TypeError(\n        `Unrecognized \"${root.protocol}\" snap location protocol.`,\n      );\n  }\n}\n"],"names":["detectSnapLocation","location","opts","allowHttp","allowLocal","root","URL","protocol","NpmLocation","assert","TypeError","LocalLocation","HttpLocation"],"mappings":";;;;+BAmDgBA;;;eAAAA;;;uBAlDO;sBAEM;uBACC;qBAEF;AA6CrB,SAASA,mBACdC,QAAsB,EACtBC,IAAgC;IAEhC,MAAMC,YAAYD,MAAMC,aAAa;IACrC,MAAMC,aAAaF,MAAME,cAAc;IACvC,MAAMC,OAAO,IAAIC,IAAIL;IACrB,OAAQI,KAAKE,QAAQ;QACnB,KAAK;YACH,OAAO,IAAIC,gBAAW,CAACH,MAAMH;QAC/B,KAAK;YACHO,IAAAA,aAAM,EAACL,YAAY,IAAIM,UAAU;YACjC,OAAO,IAAIC,oBAAa,CAACN,MAAMH;QACjC,KAAK;QACL,KAAK;YACHO,IAAAA,aAAM,EACJN,WACA,IAAIO,UAAU;YAEhB,OAAO,IAAIE,kBAAY,CAACP,MAAMH;QAChC;YACE,MAAM,IAAIQ,UACR,CAAC,cAAc,EAAEL,KAAKE,QAAQ,CAAC,yBAAyB,CAAC;IAE/D;AACF"}