repl-sdk 0.0.0 → 1.0.0

package/src/npm.js

@@ -0,0 +1,58 @@
+import packageNameRegex from 'package-name-regex';
+
+import { cache } from './cache.js';
+import { assert } from './utils.js';
+
+/**
+ * @type {Map<string, unknown>} namp@version => manifest
+ */
+const npmInfoCache = new Map();
+
+/**
+ * @param {string} name
+ * @param {string} version
+ */
+export async function getNPMInfo(name, version) {
+  const key = `${name}@${version}`;
+
+  assert(`Must pass valid npm-compatible package name`, packageNameRegex.test(name));
+
+  const existing = npmInfoCache.get(key);
+
+  if (existing) {
+    return existing;
+  }
+
+  return cache.cachedPromise(`getNPMInfo:${key}`, async () => {
+    assert(`Cannot get data from NPM without specifying the name of the package`, name);
+    assert(`Version is required. It may be 'latest'`, version);
+
+    const response = await fetch(`https://registry.npmjs.org/${name}`);
+    const json = await response.json();
+
+    npmInfoCache.set(key, json);
+
+    return json;
+  });
+}
+
+/**
+ * @param {any} npmInfo
+ * @param {string} requestedVersion
+ */
+export async function getTarUrl(npmInfo, requestedVersion) {
+  const json = npmInfo;
+
+  if (json.error) {
+    throw new Error(json.error);
+  }
+
+  const tag =
+    requestedVersion in json['dist-tags']
+      ? json['dist-tags'][requestedVersion]
+      : (requestedVersion ?? json['dist-tags'].latest);
+
+  const requested = json.versions[tag];
+
+  return requested.dist.tarball;
+}

package/src/request.Request.test.ts

@@ -0,0 +1,59 @@
+import { expect as errorExpect, it } from 'vitest';
+
+const expect = errorExpect.soft;
+
+import { getTarRequestId, idFromRequestUrl, Request } from './request.js';
+
+it('works with scope', () => {
+  const request = Request.of({ to: '@iconify/utils' });
+
+  expect(request.name).toBe('@iconify/utils');
+  expect(request.from).toBe(undefined);
+  expect(request.to).toBe('.');
+  expect(request.version).toBe('latest');
+});
+
+it('works with parent request id', () => {
+  const url = getTarRequestId({ to: 'example-library' });
+  const id = idFromRequestUrl(url);
+
+  const request = Request.of({ to: './lib/index.js', from: id });
+
+  expect(request.name).toBe('example-library');
+  expect(request.version).toBe('latest');
+  expect(request.from).toBe(Request.fromRequestId(id));
+  expect(request.to).toBe('./lib/index.js');
+});
+
+it('works with version and from', () => {
+  const url = getTarRequestId({ to: '@iconify/utils@1.0.0/bar.js' });
+  const id = idFromRequestUrl(url);
+  const request = Request.fromSpecifier(`./foo.js?from=${id}`);
+
+  expect(request.name).toBe('@iconify/utils');
+  expect(request.from).toBe(Request.fromRequestId(id));
+  expect(request.to).toBe('./foo.js');
+  expect(request.version).toBe('1.0.0');
+});
+
+it('works with subpath imports', () => {
+  const url = getTarRequestId({ to: '@iconify/utils/bar.js' });
+  const id = idFromRequestUrl(url);
+  const request = Request.fromSpecifier(`#foo/hello.js?from=${id}`);
+
+  expect(request.name).toBe('@iconify/utils');
+  expect(request.from).toBe(Request.fromRequestId(id));
+  expect(request.to).toBe('#foo/hello.js');
+  expect(request.version).toBe('latest');
+});
+
+it('works with up URLs', () => {
+  const url = getTarRequestId({ to: 'hast-util-to-html/utils/foo/bar.js' });
+  const id = idFromRequestUrl(url);
+  const request = Request.fromSpecifier(`../../utils/siblings.js?from=${id}`);
+
+  expect(request.name).toBe('hast-util-to-html');
+  expect(request.from).toBe(Request.fromRequestId(id));
+  expect(request.to).toBe('../../utils/siblings.js');
+  expect(request.version).toBe('latest');
+});

package/src/request.js

@@ -0,0 +1,140 @@
+import { cache } from './cache.js';
+import { parseSpecifier } from './specifier.js';
+import { assert, unzippedPrefix } from './utils.js';
+
+let requestId = 1;
+
+function requestKey() {
+  return `repl-request-${requestId++}`;
+}
+
+/**
+ * @param {{ to: string, from?: string }} options
+ * @returns {string} the id of the request
+ */
+export function idForRequest({ to, from }) {
+  const url = getTarRequestId({ to, from });
+
+  return idFromRequestUrl(url);
+}
+
+/**
+ * @param {{ to: string, from?: string }} options
+ * @returns {string} the URL of the request
+ */
+export function getTarRequestId({ to, from }) {
+  const request = Request.of({ to, from });
+
+  const key = requestKey();
+
+  cache.requestCache.set(key, request);
+
+  return `${unzippedPrefix}/${key}`;
+}
+
+/**
+ * @param {string} url
+ * @returnns {string}
+ */
+export function idFromRequestUrl(url) {
+  return url.replace(unzippedPrefix + '/', '');
+}
+
+export class Request {
+  static get #idCache() {
+    return cache.requestCache;
+  }
+
+  /**
+   * @param {{ to: string, from?: string }} toFrom
+   */
+  static of({ to, from }) {
+    const isRoot = to.match(/^[A-Za-z@]/);
+    const fromId = from?.replace(unzippedPrefix + '/', '');
+    const request = Request.fromSpecifier(isRoot ? to : `${to}?from=${fromId}`);
+
+    return request;
+  }
+
+  /**
+   * @param {string} id
+   */
+  static fromRequestId(id) {
+    const request = Request.#idCache.get(id);
+
+    assert(`Could not find request from id:${id}`, request);
+
+    return request;
+  }
+
+  /**
+   * @param {string} specifier
+   */
+  static fromSpecifier(specifier) {
+    return new Request(specifier);
+  }
+
+  /** @type {string} */
+  #to;
+
+  /** @type {Request | undefined} */
+  #from;
+
+  /**
+   * @private
+   * @param {string} specifier
+   */
+  constructor(specifier) {
+    const removedPrefix = specifier.replace(unzippedPrefix, '');
+    const [full, query] = removedPrefix.split('?');
+
+    this.original = specifier;
+
+    assert(`Invalid specifier: ${specifier}`, full);
+
+    if (full.startsWith('.') || full.startsWith('#')) {
+      if (!query) {
+        throw new Error(
+          `Missing query, ?from for specifier: ${specifier}. From is required for relative and subpath-imports.`
+        );
+      }
+    }
+
+    /**
+     * This will either be '.' or have the leading ./
+     */
+    this.#to = full;
+
+    if (query) {
+      const search = new URLSearchParams(query);
+      const fromQp = search.get('from');
+
+      assert(`Missing query, ?from for specifier: ${specifier}`, fromQp);
+
+      const from = Request.fromRequestId(fromQp);
+
+      this.#from = from;
+      this.name = from.name;
+      this.version = from.version;
+    } else {
+      const parsed = parseSpecifier(full);
+      const { name, version = 'latest', path } = parsed;
+
+      this.name = name;
+      this.version = version.replace(/\.+$/, '');
+      this.#to = path;
+    }
+  }
+
+  get to() {
+    return this.#to;
+  }
+
+  get from() {
+    return this.#from;
+  }
+
+  get key() {
+    return `__name__/${this.name}[AT:V]${this.version}/__to__/${this.to}`;
+  }
+}

package/src/resolve.fromImports.test.ts

@@ -0,0 +1,35 @@
+import { expect as errorExpect, it } from 'vitest';
+
+import { idForRequest, Request } from './request.js';
+import { fromImports } from './resolve.js';
+
+import type { UntarredPackage } from './types.js';
+
+const expect = errorExpect.soft;
+
+it('resolves subpath imports', () => {
+  const untarred = {
+    contents: {
+      'pkg/standalone.js': 'entry file',
+      'pkg/compiler.js': 'target file',
+      'pkg/compiler/example.js': 'target file',
+    },
+    manifest: {
+      exports: {
+        '.': {
+          browser: { default: './pkg/standalone.js' },
+          default: { default: './pkg/node.cjs' },
+        },
+      },
+      imports: {
+        '#compiler': './pkg/compiler.js',
+        '#compiler/*': './pkg/compiler/*.js',
+      },
+    },
+  };
+  const from = idForRequest({ to: 'content-tag' });
+  const request = Request.of({ to: '#compiler', from });
+  const answer = fromImports(untarred as unknown as UntarredPackage, request, undefined);
+
+  expect(answer?.inTarFile).toBe('pkg/compiler.js');
+});

package/src/resolve.fromInternalImport.test.ts

@@ -0,0 +1,69 @@
+import { expect as errorExpect, it } from 'vitest';
+
+import { idForRequest, Request } from './request.js';
+import { fromInternalImport } from './resolve.js';
+
+import type { UntarredPackage } from './types.js';
+
+const expect = errorExpect.soft;
+
+it('resolves a private file (content-tag)', () => {
+  const untarred = {
+    contents: {
+      'pkg/standalone.js': 'entry file',
+      'pkg/standalone/content_tag.js': 'target file',
+    },
+    manifest: {
+      exports: {
+        '.': {
+          browser: { default: './pkg/standalone.js' },
+          default: { default: './pkg/node.cjs' },
+        },
+        './standalone': {
+          import: { default: './pkg/standalone.js' },
+          require: { default: './pkg/stubs/require.cjs' },
+        },
+      },
+    },
+  };
+
+  const from = idForRequest({ to: 'content-tag' });
+  const request = Request.of({ to: './standalone/content_tag.js', from });
+  const answer = fromInternalImport(untarred as unknown as UntarredPackage, request, undefined);
+
+  expect(answer?.inTarFile).toBe('pkg/standalone/content_tag.js');
+});
+
+it('resolves a private file (rehype-raw)', () => {
+  const untarred = {
+    contents: {
+      'pkg/index.js': 'entry file',
+      'pkg/lib/index.js': 'target file',
+    },
+    manifest: {
+      exports: './index.js',
+    },
+  };
+  const from = idForRequest({ to: 'rehype-raw' });
+  const request = Request.of({ to: './lib/index.js', from });
+  const answer = fromInternalImport(untarred as unknown as UntarredPackage, request, undefined);
+
+  expect(answer?.inTarFile).toBe('pkg/lib/index.js');
+});
+
+it('resolves the entrypoint (unist-util-visit)', () => {
+  const untarred = {
+    contents: {
+      'index.js': 'contents',
+      'lib/index.js': 'contents',
+    },
+    manifest: {
+      exports: './index.js',
+    },
+  };
+  const from = idForRequest({ to: 'unist-util-visit' });
+  const request = Request.of({ to: './lib/index.js', from });
+  const answer = fromInternalImport(untarred as unknown as UntarredPackage, request, undefined);
+
+  expect(answer?.inTarFile).toBe('lib/index.js');
+});