@atlaspack/cache 3.2.16-typescript-bc4459c37.0 → 3.2.16

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @atlaspack/cache
 
+## 3.2.16
+
+### Patch Changes
+
+- Updated dependencies [[`069de47`](https://github.com/atlassian-labs/atlaspack/commit/069de478e64fb5889f6f2ce023eb510782767fbd)]:
+  - @atlaspack/feature-flags@2.20.0
+  - @atlaspack/fs@2.15.16
+  - @atlaspack/utils@2.17.3
+
 ## 3.2.15
 
 ### Patch Changes

package/index.d.ts

@@ -0,0 +1,13 @@
+import type {FilePath} from '@atlaspack/types';
+
+import type {Cache} from './lib/types';
+
+export type {Cache} from './lib/types';
+
+export const FSCache: {
+  new (cacheDir: FilePath): Cache;
+};
+
+export const LMDBLiteCache: {
+  new (cacheDir: FilePath): Cache;
+};

package/lib/FSCache.js

@@ -57,7 +57,6 @@ var _package = _interopRequireDefault(require("../package.json"));
 var _constants = require("./constants");
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 // flowlint-next-line untyped-import:off
-
 const pipeline = (0, _util().promisify)(_stream().default.pipeline);
 class FSCache {
   constructor(fs, cacheDir) {
@@ -72,9 +71,7 @@ class FSCache {
     // This speeds up large caches on many file systems since there are fewer files in a single directory.
     let dirPromises = [];
     for (let i = 0; i < 256; i++) {
-      dirPromises.push(
-      // @ts-expect-error TS2345
-      this.fs.mkdirp(_path().default.join(this.dir, ('00' + i.toString(16)).slice(-2))));
+      dirPromises.push(this.fs.mkdirp(_path().default.join(this.dir, ('00' + i.toString(16)).slice(-2))));
     }
     await Promise.all(dirPromises);
   }
@@ -141,19 +138,12 @@ class FSCache {
     const writePromises = [];
     if (chunks === 1) {
       // If there's one chunk, don't slice the content
-      writePromises.push(
-      // @ts-expect-error TS2345
-      this.fs.writeFile(this.#getFilePath(key, 0), contents, {
-        // @ts-expect-error TS2353
+      writePromises.push(this.fs.writeFile(this.#getFilePath(key, 0), contents, {
         signal: options === null || options === void 0 ? void 0 : options.signal
       }));
     } else {
       for (let i = 0; i < chunks; i += 1) {
-        writePromises.push(
-        // @ts-expect-error TS2345
-        this.fs.writeFile(this.#getFilePath(key, i), typeof contents === 'string' ? contents.slice(i * _constants.WRITE_LIMIT_CHUNK, (i + 1) * _constants.WRITE_LIMIT_CHUNK) : contents.subarray(i * _constants.WRITE_LIMIT_CHUNK, (i + 1) * _constants.WRITE_LIMIT_CHUNK),
-        // @ts-expect-error TS2353
-        {
+        writePromises.push(this.fs.writeFile(this.#getFilePath(key, i), typeof contents === 'string' ? contents.slice(i * _constants.WRITE_LIMIT_CHUNK, (i + 1) * _constants.WRITE_LIMIT_CHUNK) : contents.subarray(i * _constants.WRITE_LIMIT_CHUNK, (i + 1) * _constants.WRITE_LIMIT_CHUNK), {
           signal: options === null || options === void 0 ? void 0 : options.signal
         }));
       }
@@ -168,7 +158,6 @@ class FSCache {
     let i = 0;
     let filePath = this.#getFilePath(key, i);
     while (await this.fs.exists(filePath)) {
-      // @ts-expect-error TS2345
       deletePromises.push(this.fs.rimraf(filePath));
       i += 1;
       filePath = this.#getFilePath(key, i);

package/lib/IDBCache.browser.js

@@ -34,8 +34,12 @@ function _idb() {
 }
 var _package = _interopRequireDefault(require("../package.json"));
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+// $FlowFixMe[untyped-import]
+// $FlowFixMe[untyped-import]
 const STORE_NAME = 'cache';
 class IDBCache {
+  // $FlowFixMe
+
   constructor() {
     this.store = (0, _idb().openDB)('REPL-parcel-cache', 1, {
       upgrade(db) {
@@ -71,14 +75,9 @@ class IDBCache {
     await (await this.store).put(STORE_NAME, (0, _buildCache().serialize)(value), key);
   }
   getStream(key) {
-    let dataPromise = this.store
-    // @ts-expect-error TS7006
-    .then(s => s.get(STORE_NAME, key))
-    // @ts-expect-error TS7006
-    .then(d => Buffer.from(d))
-    // @ts-expect-error TS7006
-    .catch(e => e);
+    let dataPromise = this.store.then(s => s.get(STORE_NAME, key)).then(d => Buffer.from(d)).catch(e => e);
     const stream = new (_stream().Readable)({
+      // $FlowFixMe(incompatible-call)
       async read() {
         let data = await dataPromise;
         if (data instanceof Error) {

package/lib/IDBCache.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.IDBCache = void 0;
-// @ts-expect-error TS2420
+// $FlowFixMe
 class IDBCache {
   constructor() {
     throw new Error('IDBCache is only supported in the browser');

package/lib/LMDBLiteCache.js

@@ -71,8 +71,7 @@ function _logger() {
   return data;
 }
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-// @ts-expect-error TS7016
-
+// $FlowFixMe
 const ncpAsync = (0, _util().promisify)(_ncp().default);
 class LmdbWrapper {
   constructor(lmdb) {

package/lib/types.d.ts

@@ -1,2 +1,2 @@
-import type { Cache } from '@atlaspack/types';
+import type { Cache } from "@atlaspack/types";
 export type { Cache };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atlaspack/cache",
   "description": "Interface for defining caches and file-system, IDB and LMDB implementations.",
-  "version": "3.2.16-typescript-bc4459c37.0",
+  "version": "3.2.16",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -11,23 +11,24 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "./lib/index.js",
-  "source": "./src/index.ts",
-  "types": "./lib/index.d.ts",
+  "main": "lib/index.js",
+  "source": "src/index.js",
+  "types": "index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
     "test": "mocha",
-    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
+    "build-ts": "mkdir -p lib && flow-to-ts src/types.js > lib/types.d.ts",
+    "check-ts": "tsc --noEmit index.d.ts"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.4-typescript-bc4459c37.0",
-    "@atlaspack/feature-flags": "2.19.3-typescript-bc4459c37.0",
-    "@atlaspack/fs": "2.15.16-typescript-bc4459c37.0",
-    "@atlaspack/logger": "2.14.14-typescript-bc4459c37.0",
-    "@atlaspack/rust": "3.4.2-typescript-bc4459c37.0",
-    "@atlaspack/utils": "2.17.3-typescript-bc4459c37.0",
+    "@atlaspack/build-cache": "2.13.3",
+    "@atlaspack/feature-flags": "2.20.0",
+    "@atlaspack/fs": "2.15.16",
+    "@atlaspack/logger": "2.14.13",
+    "@atlaspack/rust": "3.4.1",
+    "@atlaspack/utils": "2.17.3",
     "ncp": "^2.0.0"
   },
   "devDependencies": {
@@ -35,6 +36,5 @@
   },
   "browser": {
     "./src/IDBCache.js": "./src/IDBCache.browser.js"
-  },
-  "gitHead": "bc4459c37a38ef1f74772126637e1d8841d1fcb0"
-}
+  }
+}

package/src/{FSCache.ts → FSCache.js}

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 import type {Readable, Writable} from 'stream';
 import type {FilePath} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
@@ -21,7 +23,7 @@ import packageJson from '../package.json';
 
 import {WRITE_LIMIT_CHUNK} from './constants';
 
-const pipeline: (arg1: Readable, arg2: Writable) => Promise<void> = promisify(
+const pipeline: (Readable, Writable) => Promise<void> = promisify(
   stream.pipeline,
 );
 
@@ -40,10 +42,9 @@ export class FSCache implements Cache {
 
     // In parallel, create sub-directories for every possible hex value
     // This speeds up large caches on many file systems since there are fewer files in a single directory.
-    let dirPromises: Array<Promise<undefined>> = [];
+    let dirPromises = [];
     for (let i = 0; i < 256; i++) {
       dirPromises.push(
-        // @ts-expect-error TS2345
         this.fs.mkdirp(path.join(this.dir, ('00' + i.toString(16)).slice(-2))),
       );
     }
@@ -82,10 +83,10 @@ export class FSCache implements Cache {
     await this.fs.writeFile(this._getCachePath(key), contents);
   }
 
-  async getBuffer(key: string): Promise<Buffer | null | undefined> {
+  async getBuffer(key: string): Promise<?Buffer> {
     try {
       return await this.fs.readFile(this._getCachePath(key));
-    } catch (err: any) {
+    } catch (err) {
       if (err.code === 'ENOENT') {
         return null;
       } else {
@@ -101,11 +102,11 @@ export class FSCache implements Cache {
     return path.join(this.dir, `${key}-${index}`);
   }
 
-  async #unlinkChunks(key: string, index: number): Promise<undefined> {
+  async #unlinkChunks(key: string, index: number): Promise<void> {
     try {
       await this.fs.unlink(this.#getFilePath(key, index));
       await this.#unlinkChunks(key, index + 1);
-    } catch (err: any) {
+    } catch (err) {
       // If there's an error, no more chunks are left to delete
     }
   }
@@ -128,26 +129,21 @@ export class FSCache implements Cache {
   async setLargeBlob(
     key: string,
     contents: Buffer | string,
-    options?: {
-      signal?: AbortSignal;
-    },
+    options?: {|signal?: AbortSignal|},
   ): Promise<void> {
     const chunks = Math.ceil(contents.length / WRITE_LIMIT_CHUNK);
 
-    const writePromises: Promise<undefined>[] = [];
+    const writePromises: Promise<void>[] = [];
     if (chunks === 1) {
       // If there's one chunk, don't slice the content
       writePromises.push(
-        // @ts-expect-error TS2345
         this.fs.writeFile(this.#getFilePath(key, 0), contents, {
-          // @ts-expect-error TS2353
           signal: options?.signal,
         }),
       );
     } else {
       for (let i = 0; i < chunks; i += 1) {
         writePromises.push(
-          // @ts-expect-error TS2345
           this.fs.writeFile(
             this.#getFilePath(key, i),
             typeof contents === 'string'
@@ -159,7 +155,6 @@ export class FSCache implements Cache {
                   i * WRITE_LIMIT_CHUNK,
                   (i + 1) * WRITE_LIMIT_CHUNK,
                 ),
-            // @ts-expect-error TS2353
             {signal: options?.signal},
           ),
         );
@@ -173,13 +168,12 @@ export class FSCache implements Cache {
   }
 
   async deleteLargeBlob(key: string): Promise<void> {
-    const deletePromises: Promise<undefined>[] = [];
+    const deletePromises: Promise<void>[] = [];
 
     let i = 0;
     let filePath = this.#getFilePath(key, i);
 
     while (await this.fs.exists(filePath)) {
-      // @ts-expect-error TS2345
       deletePromises.push(this.fs.rimraf(filePath));
       i += 1;
       filePath = this.#getFilePath(key, i);
@@ -188,11 +182,11 @@ export class FSCache implements Cache {
     await Promise.all(deletePromises);
   }
 
-  async get<T>(key: string): Promise<T | null | undefined> {
+  async get<T>(key: string): Promise<?T> {
     try {
       let data = await this.fs.readFile(this._getCachePath(key));
       return deserialize(data);
-    } catch (err: any) {
+    } catch (err) {
       if (err.code === 'ENOENT') {
         return null;
       } else {
@@ -201,13 +195,13 @@ export class FSCache implements Cache {
     }
   }
 
-  async set(key: string, value: unknown): Promise<void> {
+  async set(key: string, value: mixed): Promise<void> {
     try {
       let blobPath = this._getCachePath(key);
       let data = serialize(value);
 
       await this.fs.writeFile(blobPath, data);
-    } catch (err: any) {
+    } catch (err) {
       logger.error(err, '@atlaspack/cache');
     }
   }

package/src/{IDBCache.browser.ts → IDBCache.browser.js}

@@ -1,3 +1,4 @@
+// @flow strict-local
 import type {Cache} from './types';
 
 import {Readable} from 'stream';
@@ -8,18 +9,21 @@ import {
   serialize,
 } from '@atlaspack/build-cache';
 import {bufferStream} from '@atlaspack/utils';
+// $FlowFixMe[untyped-import]
 import {openDB} from 'idb';
 
+// $FlowFixMe[untyped-import]
 import packageJson from '../package.json';
 
 const STORE_NAME = 'cache';
 
 export class IDBCache implements Cache {
+  // $FlowFixMe
   store: any;
 
   constructor() {
     this.store = openDB('REPL-parcel-cache', 1, {
-      upgrade(db: any) {
+      upgrade(db) {
         db.createObjectStore(STORE_NAME);
       },
       blocked() {},
@@ -32,7 +36,7 @@ export class IDBCache implements Cache {
     return Promise.resolve();
   }
 
-  serialize(): Record<any, any> {
+  serialize(): {||} {
     return {
       /*::...null*/
     };
@@ -46,7 +50,7 @@ export class IDBCache implements Cache {
     return Promise.resolve(this.store.get(key) != null);
   }
 
-  async get<T>(key: string): Promise<T | null | undefined> {
+  async get<T>(key: string): Promise<?T> {
     let data = await (await this.store).get(STORE_NAME, key);
     if (data == null) {
       return null;
@@ -55,19 +59,17 @@ export class IDBCache implements Cache {
     return Promise.resolve(deserialize(data));
   }
 
-  async set(key: string, value: unknown): Promise<void> {
+  async set(key: string, value: mixed): Promise<void> {
     await (await this.store).put(STORE_NAME, serialize(value), key);
   }
 
   getStream(key: string): Readable {
     let dataPromise = this.store
-      // @ts-expect-error TS7006
       .then((s) => s.get(STORE_NAME, key))
-      // @ts-expect-error TS7006
       .then((d) => Buffer.from(d))
-      // @ts-expect-error TS7006
       .catch((e) => e);
     const stream = new Readable({
+      // $FlowFixMe(incompatible-call)
       async read() {
         let data = await dataPromise;
         if (data instanceof Error) {
@@ -116,7 +118,7 @@ export class IDBCache implements Cache {
   //   ]);
   // }
 
-  async getBuffer(key: string): Promise<Buffer | null | undefined> {
+  async getBuffer(key: string): Promise<?Buffer> {
     let data = await (await this.store).get(STORE_NAME, key);
     if (data == null) {
       return null;

package/src/{IDBCache.ts → IDBCache.js}

@@ -1,6 +1,7 @@
+// @flow strict-local
 import type {Cache} from './types';
 
-// @ts-expect-error TS2420
+// $FlowFixMe
 export class IDBCache implements Cache {
   constructor() {
     throw new Error('IDBCache is only supported in the browser');

package/src/{LMDBLiteCache.ts → LMDBLiteCache.js}

@@ -1,3 +1,5 @@
+// @flow strict-local
+
 import {
   deserialize,
   registerSerializableClass,
@@ -8,12 +10,12 @@ import {Lmdb} from '@atlaspack/rust';
 import type {FilePath} from '@atlaspack/types';
 import type {Cache} from './types';
 import type {Readable, Writable} from 'stream';
-// @ts-expect-error TS7016
 import ncp from 'ncp';
 import {promisify} from 'util';
 import stream from 'stream';
 import path from 'path';
 import {NodeFS} from '@atlaspack/fs';
+// $FlowFixMe
 import packageJson from '../package.json';
 import {FSCache} from './FSCache';
 import {instrumentAsync} from '@atlaspack/logger';
@@ -87,13 +89,13 @@ export function open(
   );
 }
 
-const pipeline: (arg1: Readable, arg2: Writable) => Promise<void> = promisify(
+const pipeline: (Readable, Writable) => Promise<void> = promisify(
   stream.pipeline,
 );
 
-export type SerLMDBLiteCache = {
-  dir: FilePath;
-};
+export type SerLMDBLiteCache = {|
+  dir: FilePath,
+|};
 
 export class LMDBLiteCache implements Cache {
   fs: NodeFS;
@@ -147,7 +149,7 @@ export class LMDBLiteCache implements Cache {
     return Promise.resolve(this.store.has(key));
   }
 
-  get<T>(key: string): Promise<T | null | undefined> {
+  get<T>(key: string): Promise<?T> {
     let data = this.store.get(key);
     if (data == null) {
       return Promise.resolve(null);
@@ -156,7 +158,7 @@ export class LMDBLiteCache implements Cache {
     return Promise.resolve(deserialize(data));
   }
 
-  async set(key: string, value: unknown): Promise<void> {
+  async set(key: string, value: mixed): Promise<void> {
     await this.setBlob(key, serialize(value));
   }
 
@@ -198,7 +200,7 @@ export class LMDBLiteCache implements Cache {
     await this.store.put(key, contents);
   }
 
-  getBuffer(key: string): Promise<Buffer | null | undefined> {
+  getBuffer(key: string): Promise<?Buffer> {
     return Promise.resolve(this.store.get(key));
   }
 
@@ -220,9 +222,7 @@ export class LMDBLiteCache implements Cache {
   async setLargeBlob(
     key: string,
     contents: Buffer | string,
-    options?: {
-      signal?: AbortSignal;
-    },
+    options?: {|signal?: AbortSignal|},
   ): Promise<void> {
     if (!getFeatureFlag('cachePerformanceImprovements')) {
       return this.fsCache.setLargeBlob(key, contents, options);

package/src/{constants.ts → constants.js}

@@ -1,2 +1,4 @@
+// @flow strict-local
+
 // Node has a file size limit of 2 GB
 export const WRITE_LIMIT_CHUNK = 2 * 1024 ** 3;

package/src/{index.ts → index.js}

@@ -1,3 +1,5 @@
+// @flow
+
 export * from './FSCache';
 export * from './IDBCache';
 export * from './LMDBLiteCache';

package/src/{types.ts → types.js}

@@ -1,3 +1,4 @@
+// @flow
 import type {Cache} from '@atlaspack/types';
 
 export type {Cache};

package/test/{LMDBLiteCache.test.ts → LMDBLiteCache.test.js}

@@ -1,3 +1,5 @@
+// @flow
+
 import * as fs from 'fs';
 import * as path from 'path';
 import {tmpdir} from 'os';
@@ -10,7 +12,7 @@ import {initializeMonitoring} from '@atlaspack/rust';
 const cacheDir = path.join(tmpdir(), 'lmdb-lite-cache-tests');
 
 describe('LMDBLiteCache', () => {
-  let cache: any;
+  let cache;
 
   beforeEach(async () => {
     await fs.promises.rm(cacheDir, {recursive: true, force: true});
@@ -127,7 +129,7 @@ describe('LMDBLiteCache', () => {
       await cache.ensure();
       await cache.setBlob(`key${i}`, Buffer.from(serialize({value: i})));
 
-      await new Promise((resolve: any) => setTimeout(resolve, 10));
+      await new Promise((resolve) => setTimeout(resolve, 10));
     }
 
     const finalCache = new LMDBLiteCache(testDir);
@@ -142,7 +144,7 @@ describe('LMDBLiteCache', () => {
 
     try {
       initializeMonitoring();
-    } catch (error: any) {
+    } catch (error) {
       /* empty */
     }
 
@@ -163,8 +165,8 @@ describe('LMDBLiteCache', () => {
 
     const numWorkers = 10;
 
-    const workers: Array<any> = [];
-    const responsePromises: Array<any> = [];
+    const workers = [];
+    const responsePromises = [];
     for (let i = 0; i < numWorkers; i++) {
       const worker = new Worker(path.join(__dirname, 'workerThreadsTest.js'), {
         workerData: {
@@ -173,16 +175,16 @@ describe('LMDBLiteCache', () => {
       });
       workers.push(worker);
 
-      const responsePromise = new Promise((resolve: any, reject: any) => {
+      const responsePromise = new Promise((resolve, reject) => {
         worker.addListener('error', (error: Error) => {
           reject(error);
         });
-        worker.addListener('message', (message: any) => {
+        worker.addListener('message', (message) => {
           resolve(message);
         });
       });
 
-      worker.addListener('message', (message: any) => {
+      worker.addListener('message', (message) => {
         // eslint-disable-next-line no-console
         console.log('Worker message', message);
       });
@@ -234,7 +236,7 @@ describe('LMDBLiteCache', () => {
         workerId: worker.threadId,
       });
 
-      await new Promise((resolve: any) => setTimeout(resolve, 500));
+      await new Promise((resolve) => setTimeout(resolve, 500));
       worker.terminate();
     }
   });

package/LICENSE

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright (c) 2024 Atlassian US., Inc.
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

package/lib/FSCache.d.ts

@@ -1,27 +0,0 @@
-import type { Readable } from 'stream';
-import type { FilePath } from '@atlaspack/types';
-import type { FileSystem } from '@atlaspack/fs';
-import type { Cache } from './types';
-export declare class FSCache implements Cache {
-    #private;
-    fs: FileSystem;
-    dir: FilePath;
-    constructor(fs: FileSystem, cacheDir: FilePath);
-    ensure(): Promise<void>;
-    _getCachePath(cacheId: string): FilePath;
-    getStream(key: string): Readable;
-    setStream(key: string, stream: Readable): Promise<void>;
-    has(key: string): Promise<boolean>;
-    getBlob(key: string): Promise<Buffer>;
-    setBlob(key: string, contents: Buffer | string): Promise<void>;
-    getBuffer(key: string): Promise<Buffer | null | undefined>;
-    hasLargeBlob(key: string): Promise<boolean>;
-    getLargeBlob(key: string): Promise<Buffer>;
-    setLargeBlob(key: string, contents: Buffer | string, options?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    deleteLargeBlob(key: string): Promise<void>;
-    get<T>(key: string): Promise<T | null | undefined>;
-    set(key: string, value: unknown): Promise<void>;
-    refresh(): void;
-}

package/lib/IDBCache.browser.d.ts

@@ -1,22 +0,0 @@
-import type { Cache } from './types';
-import { Readable } from 'stream';
-export declare class IDBCache implements Cache {
-    store: any;
-    constructor();
-    ensure(): Promise<void>;
-    serialize(): Record<any, any>;
-    static deserialize(): IDBCache;
-    has(key: string): Promise<boolean>;
-    get<T>(key: string): Promise<T | null | undefined>;
-    set(key: string, value: unknown): Promise<void>;
-    getStream(key: string): Readable;
-    setStream(key: string, stream: Readable): Promise<void>;
-    getBlob(key: string): Promise<Buffer>;
-    setBlob(key: string, contents: Buffer | string): Promise<void>;
-    getBuffer(key: string): Promise<Buffer | null | undefined>;
-    hasLargeBlob(key: string): Promise<boolean>;
-    getLargeBlob(key: string): Promise<Buffer>;
-    setLargeBlob(key: string, contents: Buffer | string): Promise<void>;
-    deleteLargeBlob(key: string): Promise<void>;
-    refresh(): void;
-}

package/lib/IDBCache.d.ts

@@ -1,4 +0,0 @@
-import type { Cache } from './types';
-export declare class IDBCache implements Cache {
-    constructor();
-}

package/lib/LMDBLiteCache.d.ts

@@ -1,78 +0,0 @@
-import { Lmdb } from '@atlaspack/rust';
-import type { FilePath } from '@atlaspack/types';
-import type { Cache } from './types';
-import type { Readable } from 'stream';
-import { NodeFS } from '@atlaspack/fs';
-import { FSCache } from './FSCache';
-interface DBOpenOptions {
-    name: string;
-    encoding: string;
-    compression: boolean;
-}
-export declare class LmdbWrapper {
-    lmdb: Lmdb;
-    constructor(lmdb: Lmdb);
-    has(key: string): boolean;
-    delete(key: string): Promise<void>;
-    get(key: string): Buffer | null;
-    put(key: string, value: Buffer | string): Promise<void>;
-    keys(): Iterable<string>;
-    compact(targetPath: string): void;
-}
-export declare function open(directory: string, openOptions: DBOpenOptions): LmdbWrapper;
-export type SerLMDBLiteCache = {
-    dir: FilePath;
-};
-export declare class LMDBLiteCache implements Cache {
-    fs: NodeFS;
-    dir: FilePath;
-    store: LmdbWrapper;
-    fsCache: FSCache;
-    /**
-     * Directory where we store raw files.
-     */
-    cacheFilesDirectory: FilePath;
-    constructor(cacheDir: FilePath);
-    /**
-     * Use this to pass the native LMDB instance back to Rust.
-     */
-    getNativeRef(): Lmdb;
-    ensure(): Promise<void>;
-    serialize(): SerLMDBLiteCache;
-    static deserialize(cache: SerLMDBLiteCache): LMDBLiteCache;
-    has(key: string): Promise<boolean>;
-    get<T>(key: string): Promise<T | null | undefined>;
-    set(key: string, value: unknown): Promise<void>;
-    getStream(key: string): Readable;
-    setStream(key: string, stream: Readable): Promise<void>;
-    getBlob(key: string): Promise<Buffer>;
-    getBlobSync(key: string): Buffer;
-    setBlob(key: string, contents: Buffer | string): Promise<void>;
-    getBuffer(key: string): Promise<Buffer | null | undefined>;
-    hasLargeBlob(key: string): Promise<boolean>;
-    getLargeBlob(key: string): Promise<Buffer>;
-    setLargeBlob(key: string, contents: Buffer | string, options?: {
-        signal?: AbortSignal;
-    }): Promise<void>;
-    /**
-     * @deprecated Use store.delete instead.
-     */
-    deleteLargeBlob(key: string): Promise<void>;
-    keys(): Iterable<string>;
-    compact(targetPath: string): Promise<void>;
-    refresh(): void;
-    /**
-     * Streams, packages are stored in files instead of LMDB.
-     *
-     * On this case, if a cache key happens to have a parent traversal, ../..
-     * it is treated specially
-     *
-     * That is, something/../something and something are meant to be different
-     * keys.
-     *
-     * Plus we do not want to store values outside of the cache directory.
-     */
-    getFileKey(key: string): string;
-    clear(): Promise<void>;
-}
-export {};

package/lib/constants.d.ts

@@ -1 +0,0 @@
-export declare const WRITE_LIMIT_CHUNK: number;

package/lib/index.d.ts

@@ -1,4 +0,0 @@
-export * from './FSCache';
-export * from './IDBCache';
-export * from './LMDBLiteCache';
-export type { Cache } from './types';

package/tsconfig.json

@@ -1,4 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "include": ["src"]
-}