@atlaspack/cache 3.2.16-typescript-1fd1095e8.0 → 3.2.16-typescript-e99c742e9.0

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/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.d.ts

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

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/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

@@ -0,0 +1,2 @@
+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-1fd1095e8.0",
+  "version": "3.2.16-typescript-e99c742e9.0",
   "license": "(MIT OR Apache-2.0)",
   "type": "commonjs",
   "publishConfig": {
@@ -11,23 +11,23 @@
     "type": "git",
     "url": "https://github.com/atlassian-labs/atlaspack.git"
   },
-  "main": "lib/index.js",
-  "source": "src/index.ts",
-  "types": "src/index.ts",
+  "main": "./lib/index.js",
+  "source": "./src/index.ts",
+  "types": "./lib/index.d.ts",
   "engines": {
     "node": ">= 16.0.0"
   },
   "scripts": {
     "test": "mocha",
-    "check-ts": "tsc --noEmit"
+    "check-ts": "tsc --emitDeclarationOnly --rootDir src"
   },
   "dependencies": {
-    "@atlaspack/build-cache": "2.13.4-typescript-1fd1095e8.0",
-    "@atlaspack/feature-flags": "2.19.3-typescript-1fd1095e8.0",
-    "@atlaspack/fs": "2.15.16-typescript-1fd1095e8.0",
-    "@atlaspack/logger": "2.14.14-typescript-1fd1095e8.0",
-    "@atlaspack/rust": "3.4.2-typescript-1fd1095e8.0",
-    "@atlaspack/utils": "2.17.3-typescript-1fd1095e8.0",
+    "@atlaspack/build-cache": "2.13.4-typescript-e99c742e9.0",
+    "@atlaspack/feature-flags": "2.19.3-typescript-e99c742e9.0",
+    "@atlaspack/fs": "2.15.16-typescript-e99c742e9.0",
+    "@atlaspack/logger": "2.14.14-typescript-e99c742e9.0",
+    "@atlaspack/rust": "3.4.2-typescript-e99c742e9.0",
+    "@atlaspack/utils": "2.17.3-typescript-e99c742e9.0",
     "ncp": "^2.0.0"
   },
   "devDependencies": {
@@ -36,5 +36,5 @@
   "browser": {
     "./src/IDBCache.js": "./src/IDBCache.browser.js"
   },
-  "gitHead": "1fd1095e86da1e50d6c7819c0f132ce09a2bf396"
-}
+  "gitHead": "e99c742e92175ac411d807daf2ba45d5bacebb58"
+}

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;
-};