sproutboat 0.28.0 → 0.29.0

package/vendor/ltx-restore/ltx/types.ts.txt

@@ -0,0 +1,152 @@
+import { LTXFormatError } from '../errors.ts';
+/**
+ * LTX shared types and small value helpers.
+ *
+ * 64-bit unsigned values (TXID, Checksum) are represented as `bigint` to keep
+ * exact semantics. Page numbers and file offsets/sizes fit within JS safe
+ * integers for any realistic database, so they are `number`.
+ */
+
+export type TXID = bigint;
+export type Checksum = bigint;
+
+/** Pos is the transactional position of a database. */
+export interface Pos {
+  txID: TXID;
+  postApplyChecksum: Checksum;
+}
+
+/** Formats a TXID as a fixed-width 16-char lowercase hex string. */
+export function formatTXID(txID: bigint): string {
+  return txID.toString(16).padStart(16, '0');
+}
+
+/** Parses a 16-character hex string into a TXID. */
+export function parseTXID(s: string): bigint {
+  if (s.length !== 16) {
+    throw new LTXFormatError(`invalid formatted transaction id length: ${JSON.stringify(s)}`);
+  }
+  if (!/^[0-9a-fA-F]{16}$/.test(s)) {
+    throw new LTXFormatError(`invalid transaction id format: ${JSON.stringify(s)}`);
+  }
+  return BigInt(`0x${s}`);
+}
+
+/** Formats a Checksum as a fixed-width 16-char lowercase hex string. */
+export function formatChecksum(chk: bigint): string {
+  return chk.toString(16).padStart(16, '0');
+}
+
+/** Parses a 16-character hex string into a Checksum. */
+export function parseChecksum(s: string): bigint {
+  if (s.length !== 16) {
+    throw new LTXFormatError(`invalid formatted checksum length: ${JSON.stringify(s)}`);
+  }
+  if (!/^[0-9a-fA-F]{16}$/.test(s)) {
+    throw new LTXFormatError(`invalid checksum format: ${JSON.stringify(s)}`);
+  }
+  return BigInt(`0x${s}`);
+}
+
+export function parsePos(s: string): Pos {
+  if (s.length !== 33) {
+    throw new LTXFormatError(`invalid formatted position length: ${JSON.stringify(s)}`);
+  }
+  return {
+    txID: parseTXID(s.slice(0, 16)),
+    postApplyChecksum: parseChecksum(s.slice(17)),
+  };
+}
+
+export function formatPos(p: Pos): string {
+  return `${formatTXID(p.txID)}/${formatChecksum(p.postApplyChecksum)}`;
+}
+
+export function isZeroPos(p: Pos): boolean {
+  return p.txID === 0n && p.postApplyChecksum === 0n;
+}
+
+/** Header flags. */
+export interface Header {
+  version: number;
+  flags: number;
+  pageSize: number;
+  commit: number;
+  minTXID: TXID;
+  maxTXID: TXID;
+  timestamp: bigint; // milliseconds since Unix epoch
+  preApplyChecksum: Checksum;
+  walOffset: bigint;
+  walSize: bigint;
+  walSalt1: number;
+  walSalt2: number;
+  nodeID: bigint;
+}
+
+export function isSnapshot(h: Header): boolean {
+  return h.minTXID === 1n;
+}
+
+export function noChecksum(h: Header): boolean {
+  return (h.flags & HeaderFlagNoChecksumBit) !== 0;
+}
+
+const HeaderFlagNoChecksumBit = 0x00000002;
+
+/** PageHeader represents the header for a single page in an LTX file. */
+export interface PageHeader {
+  pgno: number; // uint32
+  flags: number; // uint16
+}
+
+export function isZeroPageHeader(h: PageHeader): boolean {
+  return h.pgno === 0 && h.flags === 0;
+}
+
+/** Trailer represents the ending frame of an LTX file. */
+export interface Trailer {
+  postApplyChecksum: Checksum;
+  fileChecksum: Checksum;
+}
+
+/** PageIndexElem describes a single page entry in the file's page index. */
+export interface PageIndexElem {
+  level: number;
+  minTXID: TXID;
+  maxTXID: TXID;
+  offset: number;
+  size: number;
+}
+
+export type PageIndex = Map<number, PageIndexElem>;
+
+/** FileInfo represents file information about an LTX file. */
+export interface FileInfo {
+  level: number;
+  minTXID: TXID;
+  maxTXID: TXID;
+  preApplyChecksum?: Checksum;
+  postApplyChecksum?: Checksum;
+  size: number;
+  createdAt: number; // ms since Unix epoch
+  checksum?: Checksum;
+}
+
+export function preApplyPos(info: FileInfo): Pos {
+  return {
+    txID: info.minTXID - 1n,
+    postApplyChecksum: info.preApplyChecksum ?? 0n,
+  };
+}
+
+export function postApplyPos(info: FileInfo): Pos {
+  return {
+    txID: info.maxTXID,
+    postApplyChecksum: info.postApplyChecksum ?? 0n,
+  };
+}
+
+/** IsContiguous reports whether a transaction range is contiguous with prevMaxTXID. */
+export function isContiguous(prevMaxTXID: TXID, minTXID: TXID, maxTXID: TXID): boolean {
+  return minTXID <= prevMaxTXID + 1n && maxTXID > prevMaxTXID;
+}

package/vendor/ltx-restore/lz4js/README.md

@@ -0,0 +1,39 @@
+# Lz4.js [![NPM version](https://badge.fury.io/js/lz4js.svg)](https://www.npmjs.com/package/lz4js) [![Build Status](https://travis-ci.org/Benzinga/lz4js.svg?branch=master)](https://travis-ci.org/Benzinga/lz4js) [![codecov](https://codecov.io/gh/Benzinga/lz4js/branch/master/graph/badge.svg)](https://codecov.io/gh/Benzinga/lz4js)
+Lz4.js is an implementation of Lz4 designed to be used in web browsers. It contains no dependencies on external libraries or Node.JS, though it is organized as a set of CommonJS modules. It is recommended to use Browserify or WebPack to bundle this for the web browser.
+
+## Installation
+```
+npm install lz4js
+```
+
+## Usage
+```javascript
+var lz4 = require("lz4js");
+var fs = require("fs");
+
+// Compress 128 bytes of zero.
+var compressed = lz4.compress(new Array(128));
+
+// Decompress.
+var decompressed = lz4.decompress(compressed);
+
+// Compress file.bin to file.lz4.
+var data = fs.readFileSync("file.bin");
+compressed = Buffer.from(lz4.compress(data));
+fs.writeFileSync('file.lz4', compressed);
+```
+
+> **Note**: The high-level `compress` and `decompress` functions deal with framed Lz4 data and do not support raw block data nor legacy Lz4 blocks.
+
+## API
+The API accepts either `Array`s or `Uint8Array`s. Arrays are expected to be arrays of unsigned 8-bit values. The API will return `Uint8Array`s if the browser supports them, or `Array`s otherwise.
+
+  - `compress(buffer: Array, maxSize: Number): Array`
+
+    Compresses a buffer using Lz4. maxSize sets bounds on the output length; it is recommended to not specify this unless you know what you're doing.
+    Any unused buffer data will be sliced before the buffer is returned.
+
+  - `decompress(buffer: Array, maxSize: Number): Array`
+
+    Decompresses a buffer using Lz4. maxSize sets bounds on the output length; if you know the output length, this will reduce memory usage somewhat.
+    Any unused buffer data will be sliced before the buffer is returned.