@metamask/snaps-controllers 1.0.2 → 2.0.1

package/dist/{snaps → esm/snaps}/location/http.js

@@ -1,45 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HttpLocation = void 0;
-const snaps_utils_1 = require("@metamask/snaps-utils");
-const utils_1 = require("@metamask/utils");
-class HttpLocation {
-    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.
-        this.cache = new Map();
-        (0, utils_1.assertStruct)(url.toString(), snaps_utils_1.HttpSnapIdStruct, 'Invalid Snap Id: ');
-        this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
-        this.fetchOptions = opts.fetchOptions;
-        this.url = url;
+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;
+}
+import { VirtualFile, HttpSnapIdStruct, NpmSnapFileNames, createSnapManifest, normalizeRelative, parseJson } from '@metamask/snaps-utils';
+import { assert, assertStruct } from '@metamask/utils';
+export 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(snaps_utils_1.NpmSnapFileNames.Manifest, this.url).toString();
+        const canonicalPath = new URL(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, snaps_utils_1.parseJson)(contents);
-        const vfile = new snaps_utils_1.VirtualFile({
+        const manifest = parseJson(contents);
+        const vfile = new VirtualFile({
             value: contents,
-            result: (0, snaps_utils_1.createSnapManifest)(manifest),
-            path: snaps_utils_1.NpmSnapFileNames.Manifest,
-            data: { canonicalPath },
+            result: createSnapManifest(manifest),
+            path: NpmSnapFileNames.Manifest,
+            data: {
+                canonicalPath
+            }
         });
         this.validatedManifest = vfile;
         return this.manifest();
     }
     async fetch(path) {
-        const relativePath = (0, snaps_utils_1.normalizeRelative)(path);
+        const relativePath = normalizeRelative(path);
         const cached = this.cache.get(relativePath);
         if (cached !== undefined) {
             const { file, contents } = cached;
@@ -53,23 +52,45 @@ class HttpLocation {
         if (!response.ok) {
             throw new Error(`Failed to fetch "${canonicalPath}". Status code: ${response.status}.`);
         }
-        const vfile = new snaps_utils_1.VirtualFile({
+        const vfile = new VirtualFile({
             value: '',
             path: relativePath,
-            data: { canonicalPath },
+            data: {
+                canonicalPath
+            }
         });
         const blob = await response.blob();
-        (0, utils_1.assert)(!this.cache.has(relativePath), 'Corrupted cache, multiple files with same path.');
-        this.cache.set(relativePath, { file: vfile, contents: blob });
+        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_1.assert)(!path.startsWith('/'), 'Tried to parse absolute path.');
+        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);
+        assertStruct(url.toString(), HttpSnapIdStruct, 'Invalid Snap Id: ');
+        this.fetchFn = opts.fetch ?? globalThis.fetch.bind(globalThis);
+        this.fetchOptions = opts.fetchOptions;
+        this.url = url;
+    }
 }
-exports.HttpLocation = HttpLocation;
+
 //# sourceMappingURL=http.js.map

package/dist/esm/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":["VirtualFile","HttpSnapIdStruct","NpmSnapFileNames","createSnapManifest","normalizeRelative","parseJson","assert","assertStruct","HttpLocation","manifest","validatedManifest","clone","canonicalPath","URL","Manifest","url","toString","response","fetchFn","fetchOptions","ok","Error","status","contents","text","vfile","value","result","path","data","fetch","relativePath","cached","cache","get","undefined","file","Uint8Array","arrayBuffer","toCanonical","blob","has","set","root","startsWith","constructor","opts","Map","globalThis","bind"],"mappings":"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"}

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

@@ -0,0 +1,6 @@
+export * from './location';
+export * from './npm';
+export * from './local';
+export * from './http';
+
+//# sourceMappingURL=index.js.map

package/dist/esm/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":"AAAA,cAAc,aAAa;AAC3B,cAAc,QAAQ;AACtB,cAAc,UAAU;AACxB,cAAc,SAAS"}

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

@@ -0,0 +1,83 @@
+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;
+}
+import { LocalSnapIdStruct, SnapIdPrefixes } from '@metamask/snaps-utils';
+import { assert, assertStruct } from '@metamask/utils';
+import { HttpLocation } from './http';
+var _http = /*#__PURE__*/ new WeakMap();
+export class LocalLocation {
+    async manifest() {
+        const vfile = await _class_private_field_get(this, _http).manifest();
+        return convertCanonical(vfile);
+    }
+    async fetch(path) {
+        return convertCanonical(await _class_private_field_get(this, _http).fetch(path));
+    }
+    get shouldAlwaysReload() {
+        return true;
+    }
+    constructor(url, opts = {}){
+        _class_private_field_init(this, _http, {
+            writable: true,
+            value: void 0
+        });
+        assertStruct(url.toString(), LocalSnapIdStruct, 'Invalid Snap Id');
+        // TODO(ritave): Write deepMerge() which merges fetchOptions.
+        assert(opts.fetchOptions === undefined, 'Currently adding fetch options to local: is unsupported.');
+        _class_private_field_set(this, _http, new HttpLocation(new URL(url.toString().slice(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) {
+    assert(vfile.data.canonicalPath !== undefined);
+    vfile.data.canonicalPath = `local:${vfile.data.canonicalPath}`;
+    return vfile;
+}
+
+//# sourceMappingURL=local.js.map

package/dist/esm/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":["LocalSnapIdStruct","SnapIdPrefixes","assert","assertStruct","HttpLocation","LocalLocation","manifest","vfile","http","convertCanonical","fetch","path","shouldAlwaysReload","constructor","url","opts","toString","fetchOptions","undefined","URL","slice","local","length","cache","data","canonicalPath"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AACA,SAASA,iBAAiB,EAAEC,cAAc,QAAQ,wBAAwB;AAC1E,SAASC,MAAM,EAAEC,YAAY,QAAQ,kBAAkB;AAGvD,SAASC,YAAY,QAAQ,SAAS;IAI3B;AADX,OAAO,MAAMC;IAiBX,MAAMC,WAA+C;QACnD,MAAMC,QAAQ,MAAM,yBAAA,IAAI,EAAEC,OAAKF,QAAQ;QAEvC,OAAOG,iBAAiBF;IAC1B;IAEA,MAAMG,MAAMC,IAAY,EAAwB;QAC9C,OAAOF,iBAAiB,MAAM,yBAAA,IAAI,EAAED,OAAKE,KAAK,CAACC;IACjD;IAEA,IAAIC,qBAAqB;QACvB,OAAO;IACT;IA1BAC,YAAYC,GAAQ,EAAEC,OAAoB,CAAC,CAAC,CAAE;QAF9C,gCAAS;;mBAAT,KAAA;;QAGEZ,aAAaW,IAAIE,QAAQ,IAAIhB,mBAAmB;QAChD,6DAA6D;QAC7DE,OACEa,KAAKE,YAAY,KAAKC,WACtB;uCAGIV,OAAO,IAAIJ,aACf,IAAIe,IAAIL,IAAIE,QAAQ,GAAGI,KAAK,CAACnB,eAAeoB,KAAK,CAACC,MAAM,IACxD;YAAE,GAAGP,IAAI;YAAEE,cAAc;gBAAEM,OAAO;YAAW;QAAE;IAEnD;AAeF;AAEA;;;;;CAKC,GACD,SAASd,iBACPF,KAA0B;IAE1BL,OAAOK,MAAMiB,IAAI,CAACC,aAAa,KAAKP;IACpCX,MAAMiB,IAAI,CAACC,aAAa,GAAG,CAAC,MAAM,EAAElB,MAAMiB,IAAI,CAACC,aAAa,CAAC,CAAC;IAC9D,OAAOlB;AACT"}

package/dist/esm/snaps/location/location.js

@@ -0,0 +1,30 @@
+import { assert } from '@metamask/utils';
+import { HttpLocation } from './http';
+import { LocalLocation } from './local';
+import { NpmLocation } from './npm';
+/**
+ * Auto-magically detects which SnapLocation object to create based on the provided {@link location}.
+ *
+ * @param location - A {@link https://github.com/MetaMask/SIPs/blob/main/SIPS/sip-8.md SIP-8} uri.
+ * @param opts - NPM options and feature flags.
+ * @returns SnapLocation based on url.
+ */ export 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 NpmLocation(root, opts);
+        case 'local:':
+            assert(allowLocal, new TypeError('Fetching local snaps is disabled.'));
+            return new LocalLocation(root, opts);
+        case 'http:':
+        case 'https:':
+            assert(allowHttp, new TypeError('Fetching snaps through http/https is disabled.'));
+            return new HttpLocation(root, opts);
+        default:
+            throw new TypeError(`Unrecognized "${root.protocol}" snap location protocol.`);
+    }
+}
+
+//# sourceMappingURL=location.js.map

package/dist/esm/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":["assert","HttpLocation","LocalLocation","NpmLocation","detectSnapLocation","location","opts","allowHttp","allowLocal","root","URL","protocol","TypeError"],"mappings":"AACA,SAASA,MAAM,QAAQ,kBAAkB;AAEzC,SAASC,YAAY,QAAQ,SAAS;AACtC,SAASC,aAAa,QAAQ,UAAU;AAExC,SAASC,WAAW,QAAQ,QAAQ;AAsCpC;;;;;;CAMC,GACD,OAAO,SAASC,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,IAAIR,YAAYM,MAAMH;QAC/B,KAAK;YACHN,OAAOQ,YAAY,IAAII,UAAU;YACjC,OAAO,IAAIV,cAAcO,MAAMH;QACjC,KAAK;QACL,KAAK;YACHN,OACEO,WACA,IAAIK,UAAU;YAEhB,OAAO,IAAIX,aAAaQ,MAAMH;QAChC;YACE,MAAM,IAAIM,UACR,CAAC,cAAc,EAAEH,KAAKE,QAAQ,CAAC,yBAAyB,CAAC;IAE/D;AACF"}