@atlaspack/cache 3.2.16 → 3.2.17-typescript-17c3d1dec.0

package/LICENSE

@@ -0,0 +1,201 @@
+                                 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

@@ -0,0 +1,27 @@
+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/FSCache.js

@@ -57,6 +57,7 @@ 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) {
@@ -71,7 +72,9 @@ 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(this.fs.mkdirp(_path().default.join(this.dir, ('00' + i.toString(16)).slice(-2))));
+      dirPromises.push(
+      // @ts-expect-error TS2345
+      this.fs.mkdirp(_path().default.join(this.dir, ('00' + i.toString(16)).slice(-2))));
     }
     await Promise.all(dirPromises);
   }
@@ -138,12 +141,19 @@ class FSCache {
     const writePromises = [];
     if (chunks === 1) {
       // If there's one chunk, don't slice the content
-      writePromises.push(this.fs.writeFile(this.#getFilePath(key, 0), contents, {
+      writePromises.push(
+      // @ts-expect-error TS2345
+      this.fs.writeFile(this.#getFilePath(key, 0), contents, {
+        // @ts-expect-error TS2353
         signal: options === null || options === void 0 ? void 0 : options.signal
       }));
     } else {
       for (let i = 0; i < chunks; i += 1) {
-        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), {
+        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
+        {
           signal: options === null || options === void 0 ? void 0 : options.signal
         }));
       }
@@ -158,6 +168,7 @@ 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.d.ts

@@ -0,0 +1,22 @@
+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.browser.js

@@ -34,12 +34,8 @@ 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) {
@@ -75,9 +71,14 @@ class IDBCache {
     await (await this.store).put(STORE_NAME, (0, _buildCache().serialize)(value), key);
   }
   getStream(key) {
-    let dataPromise = this.store.then(s => s.get(STORE_NAME, key)).then(d => Buffer.from(d)).catch(e => e);
+    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 (_stream().Readable)({
-      // $FlowFixMe(incompatible-call)
       async read() {
         let data = await dataPromise;
         if (data instanceof Error) {

package/lib/IDBCache.d.ts

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

package/lib/IDBCache.js

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

package/lib/LMDBLiteCache.d.ts

@@ -0,0 +1,78 @@
+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/LMDBLiteCache.js

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

package/lib/constants.d.ts

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

package/lib/index.d.ts

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

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",
+  "version": "3.2.17-typescript-17c3d1dec.0",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -11,24 +11,23 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.js",
-  "types": "index.d.ts",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
     "test": "mocha",
-    "build-ts": "mkdir -p lib && flow-to-ts src/types.js > lib/types.d.ts",
-    "check-ts": "tsc --noEmit index.d.ts"
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
   },
   "dependencies": {
-    "@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",
+    "@atlaspack/build-cache": "2.13.4-typescript-17c3d1dec.0",
+    "@atlaspack/feature-flags": "2.20.1-typescript-17c3d1dec.0",
+    "@atlaspack/fs": "2.15.17-typescript-17c3d1dec.0",
+    "@atlaspack/logger": "2.14.14-typescript-17c3d1dec.0",
+    "@atlaspack/rust": "3.4.2-typescript-17c3d1dec.0",
+    "@atlaspack/utils": "2.17.4-typescript-17c3d1dec.0",
     "ncp": "^2.0.0"
   },
   "devDependencies": {
@@ -36,5 +35,6 @@
   },
   "browser": {
     "./src/IDBCache.js": "./src/IDBCache.browser.js"
-  }
-}
+  },
+  "gitHead": "17c3d1decf641e688fcfe3ca985e80e9897b7573"
+}

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import type {Readable, Writable} from 'stream';
 import type {FilePath} from '@atlaspack/types';
 import type {FileSystem} from '@atlaspack/fs';
@@ -23,7 +21,7 @@ import packageJson from '../package.json';
 
 import {WRITE_LIMIT_CHUNK} from './constants';
 
-const pipeline: (Readable, Writable) => Promise<void> = promisify(
+const pipeline: (arg1: Readable, arg2: Writable) => Promise<void> = promisify(
   stream.pipeline,
 );
 
@@ -42,9 +40,10 @@ 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 = [];
+    let dirPromises: Array<Promise<undefined>> = [];
     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))),
       );
     }
@@ -83,10 +82,10 @@ export class FSCache implements Cache {
     await this.fs.writeFile(this._getCachePath(key), contents);
   }
 
-  async getBuffer(key: string): Promise<?Buffer> {
+  async getBuffer(key: string): Promise<Buffer | null | undefined> {
     try {
       return await this.fs.readFile(this._getCachePath(key));
-    } catch (err) {
+    } catch (err: any) {
       if (err.code === 'ENOENT') {
         return null;
       } else {
@@ -102,11 +101,11 @@ export class FSCache implements Cache {
     return path.join(this.dir, `${key}-${index}`);
   }
 
-  async #unlinkChunks(key: string, index: number): Promise<void> {
+  async #unlinkChunks(key: string, index: number): Promise<undefined> {
     try {
       await this.fs.unlink(this.#getFilePath(key, index));
       await this.#unlinkChunks(key, index + 1);
-    } catch (err) {
+    } catch (err: any) {
       // If there's an error, no more chunks are left to delete
     }
   }
@@ -129,21 +128,26 @@ 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<void>[] = [];
+    const writePromises: Promise<undefined>[] = [];
     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'
@@ -155,6 +159,7 @@ export class FSCache implements Cache {
                   i * WRITE_LIMIT_CHUNK,
                   (i + 1) * WRITE_LIMIT_CHUNK,
                 ),
+            // @ts-expect-error TS2353
             {signal: options?.signal},
           ),
         );
@@ -168,12 +173,13 @@ export class FSCache implements Cache {
   }
 
   async deleteLargeBlob(key: string): Promise<void> {
-    const deletePromises: Promise<void>[] = [];
+    const deletePromises: Promise<undefined>[] = [];
 
     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);
@@ -182,11 +188,11 @@ export class FSCache implements Cache {
     await Promise.all(deletePromises);
   }
 
-  async get<T>(key: string): Promise<?T> {
+  async get<T>(key: string): Promise<T | null | undefined> {
     try {
       let data = await this.fs.readFile(this._getCachePath(key));
       return deserialize(data);
-    } catch (err) {
+    } catch (err: any) {
       if (err.code === 'ENOENT') {
         return null;
       } else {
@@ -195,13 +201,13 @@ export class FSCache implements Cache {
     }
   }
 
-  async set(key: string, value: mixed): Promise<void> {
+  async set(key: string, value: unknown): Promise<void> {
     try {
       let blobPath = this._getCachePath(key);
       let data = serialize(value);
 
       await this.fs.writeFile(blobPath, data);
-    } catch (err) {
+    } catch (err: any) {
       logger.error(err, '@atlaspack/cache');
     }
   }

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

@@ -1,4 +1,3 @@
-// @flow strict-local
 import type {Cache} from './types';
 
 import {Readable} from 'stream';
@@ -9,21 +8,18 @@ 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) {
+      upgrade(db: any) {
         db.createObjectStore(STORE_NAME);
       },
       blocked() {},
@@ -36,7 +32,7 @@ export class IDBCache implements Cache {
     return Promise.resolve();
   }
 
-  serialize(): {||} {
+  serialize(): Record<any, any> {
     return {
       /*::...null*/
     };
@@ -50,7 +46,7 @@ export class IDBCache implements Cache {
     return Promise.resolve(this.store.get(key) != null);
   }
 
-  async get<T>(key: string): Promise<?T> {
+  async get<T>(key: string): Promise<T | null | undefined> {
     let data = await (await this.store).get(STORE_NAME, key);
     if (data == null) {
       return null;
@@ -59,17 +55,19 @@ export class IDBCache implements Cache {
     return Promise.resolve(deserialize(data));
   }
 
-  async set(key: string, value: mixed): Promise<void> {
+  async set(key: string, value: unknown): 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) {
@@ -118,7 +116,7 @@ export class IDBCache implements Cache {
   //   ]);
   // }
 
-  async getBuffer(key: string): Promise<?Buffer> {
+  async getBuffer(key: string): Promise<Buffer | null | undefined> {
     let data = await (await this.store).get(STORE_NAME, key);
     if (data == null) {
       return null;

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

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

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

@@ -1,5 +1,3 @@
-// @flow strict-local
-
 import {
   deserialize,
   registerSerializableClass,
@@ -10,12 +8,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';
@@ -89,13 +87,13 @@ export function open(
   );
 }
 
-const pipeline: (Readable, Writable) => Promise<void> = promisify(
+const pipeline: (arg1: Readable, arg2: Writable) => Promise<void> = promisify(
   stream.pipeline,
 );
 
-export type SerLMDBLiteCache = {|
-  dir: FilePath,
-|};
+export type SerLMDBLiteCache = {
+  dir: FilePath;
+};
 
 export class LMDBLiteCache implements Cache {
   fs: NodeFS;
@@ -149,7 +147,7 @@ export class LMDBLiteCache implements Cache {
     return Promise.resolve(this.store.has(key));
   }
 
-  get<T>(key: string): Promise<?T> {
+  get<T>(key: string): Promise<T | null | undefined> {
     let data = this.store.get(key);
     if (data == null) {
       return Promise.resolve(null);
@@ -158,7 +156,7 @@ export class LMDBLiteCache implements Cache {
     return Promise.resolve(deserialize(data));
   }
 
-  async set(key: string, value: mixed): Promise<void> {
+  async set(key: string, value: unknown): Promise<void> {
     await this.setBlob(key, serialize(value));
   }
 
@@ -200,7 +198,7 @@ export class LMDBLiteCache implements Cache {
     await this.store.put(key, contents);
   }
 
-  getBuffer(key: string): Promise<?Buffer> {
+  getBuffer(key: string): Promise<Buffer | null | undefined> {
     return Promise.resolve(this.store.get(key));
   }
 
@@ -222,7 +220,9 @@ 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.js → constants.ts}

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

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

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

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

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

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

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

package/tsconfig.json

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

package/index.d.ts

@@ -1,13 +0,0 @@
-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;
-};