gingersnap 0.22.0

package/errors/QueueFullError.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class QueueFullError extends Error {
+}
+
+exports.QueueFullError = QueueFullError;

package/errors/QueueFullError.d.ts

@@ -0,0 +1,2 @@
+export declare class QueueFullError extends Error {
+}

package/errors/QueueFullError.mjs

@@ -0,0 +1,4 @@
+class QueueFullError extends Error {
+}
+
+export { QueueFullError };

package/errors/StackEmptyError.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class StackEmptyError extends Error {
+}
+
+exports.StackEmptyError = StackEmptyError;

package/errors/StackEmptyError.d.ts

@@ -0,0 +1,2 @@
+export declare class StackEmptyError extends Error {
+}

package/errors/StackEmptyError.mjs

@@ -0,0 +1,4 @@
+class StackEmptyError extends Error {
+}
+
+export { StackEmptyError };

package/errors/StackFullError.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class StackFullError extends Error {
+}
+
+exports.StackFullError = StackFullError;

package/errors/StackFullError.d.ts

@@ -0,0 +1,2 @@
+export declare class StackFullError extends Error {
+}

package/errors/StackFullError.mjs

@@ -0,0 +1,4 @@
+class StackFullError extends Error {
+}
+
+export { StackFullError };

package/errors/StreamEnded.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class StreamEnded extends Error {
+}
+
+exports.StreamEnded = StreamEnded;

package/errors/StreamEnded.d.ts

@@ -0,0 +1,2 @@
+export declare class StreamEnded extends Error {
+}

package/errors/StreamEnded.mjs

@@ -0,0 +1,4 @@
+class StreamEnded extends Error {
+}
+
+export { StreamEnded };

package/errors/TimeoutError.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var FutureCancelled = require('./FutureCancelled.cjs');
+
+/**
+ * Thrown to indicate that some timed operation has exceeded the maximum duration
+ */
+class TimeoutError extends FutureCancelled.FutureCancelled {
+}
+
+exports.TimeoutError = TimeoutError;

package/errors/TimeoutError.d.ts

@@ -0,0 +1,6 @@
+import { FutureCancelled } from "./FutureCancelled";
+/**
+ * Thrown to indicate that some timed operation has exceeded the maximum duration
+ */
+export declare class TimeoutError extends FutureCancelled {
+}

package/errors/TimeoutError.mjs

@@ -0,0 +1,9 @@
+import { FutureCancelled } from './FutureCancelled.mjs';
+
+/**
+ * Thrown to indicate that some timed operation has exceeded the maximum duration
+ */
+class TimeoutError extends FutureCancelled {
+}
+
+export { TimeoutError };

package/errors/ValueDestroyedError.cjs

@@ -0,0 +1,6 @@
+'use strict';
+
+class ValueDestroyedError extends Error {
+}
+
+exports.ValueDestroyedError = ValueDestroyedError;

package/errors/ValueDestroyedError.d.ts

@@ -0,0 +1,2 @@
+export declare class ValueDestroyedError extends Error {
+}

package/errors/ValueDestroyedError.mjs

@@ -0,0 +1,4 @@
+class ValueDestroyedError extends Error {
+}
+
+export { ValueDestroyedError };

package/errors/VerificationError.cjs

@@ -0,0 +1,9 @@
+'use strict';
+
+/**
+ * Thrown to indicate an expectation failed. Many used in testing or mocks
+ */
+class VerificationError extends Error {
+}
+
+exports.VerificationError = VerificationError;

package/errors/VerificationError.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Thrown to indicate an expectation failed. Many used in testing or mocks
+ */
+export declare class VerificationError extends Error {
+}

package/errors/VerificationError.mjs

@@ -0,0 +1,7 @@
+/**
+ * Thrown to indicate an expectation failed. Many used in testing or mocks
+ */
+class VerificationError extends Error {
+}
+
+export { VerificationError };

package/errors/index.d.ts

@@ -0,0 +1,18 @@
+export * from "./AbortError";
+export * from "./CallExecutionError";
+export * from "./FutureCancelled";
+export * from "./FutureError";
+export * from "./IllegalArgumentsError";
+export * from "./InvalidType";
+export * from "./InvalidValue";
+export * from "./MissingArgumentsError";
+export * from "./NetworkError";
+export * from "./NoSuchElement";
+export * from "./NotImplemented";
+export * from "./ParsingError";
+export * from "./QueueEmptyError";
+export * from "./StackEmptyError";
+export * from "./StreamEnded";
+export * from "./TimeoutError";
+export * from "./VerificationError";
+export * from "./StackFullError";

package/errors.cjs

@@ -0,0 +1,41 @@
+'use strict';
+
+var AbortError = require('./errors/AbortError.cjs');
+var CallExecutionError = require('./errors/CallExecutionError.cjs');
+var FutureCancelled = require('./errors/FutureCancelled.cjs');
+var FutureError = require('./errors/FutureError.cjs');
+var IllegalArgumentsError = require('./errors/IllegalArgumentsError.cjs');
+var InvalidType = require('./errors/InvalidType.cjs');
+var InvalidValue = require('./errors/InvalidValue.cjs');
+var MissingArgumentsError = require('./errors/MissingArgumentsError.cjs');
+var NetworkError = require('./errors/NetworkError.cjs');
+var NoSuchElement = require('./errors/NoSuchElement.cjs');
+var NotImplemented = require('./errors/NotImplemented.cjs');
+var ParsingError = require('./errors/ParsingError.cjs');
+var QueueEmptyError = require('./errors/QueueEmptyError.cjs');
+var StackEmptyError = require('./errors/StackEmptyError.cjs');
+var StreamEnded = require('./errors/StreamEnded.cjs');
+var TimeoutError = require('./errors/TimeoutError.cjs');
+var VerificationError = require('./errors/VerificationError.cjs');
+var StackFullError = require('./errors/StackFullError.cjs');
+
+
+
+exports.AbortError = AbortError.AbortError;
+exports.CallExecutionError = CallExecutionError.CallExecutionError;
+exports.FutureCancelled = FutureCancelled.FutureCancelled;
+exports.FutureError = FutureError.FutureError;
+exports.IllegalArgumentsError = IllegalArgumentsError.IllegalArgumentsError;
+exports.InvalidType = InvalidType.InvalidType;
+exports.InvalidValue = InvalidValue.InvalidValue;
+exports.MissingArgumentsError = MissingArgumentsError.MissingArgumentsError;
+exports.NetworkError = NetworkError.NetworkError;
+exports.NoSuchElement = NoSuchElement.NoSuchElement;
+exports.NotImplemented = NotImplemented.NotImplemented;
+exports.ParsingError = ParsingError.ParsingError;
+exports.QueueEmptyError = QueueEmptyError.QueueEmptyError;
+exports.StackEmptyError = StackEmptyError.StackEmptyError;
+exports.StreamEnded = StreamEnded.StreamEnded;
+exports.TimeoutError = TimeoutError.TimeoutError;
+exports.VerificationError = VerificationError.VerificationError;
+exports.StackFullError = StackFullError.StackFullError;

package/errors.mjs

@@ -0,0 +1,18 @@
+export { AbortError } from './errors/AbortError.mjs';
+export { CallExecutionError } from './errors/CallExecutionError.mjs';
+export { FutureCancelled } from './errors/FutureCancelled.mjs';
+export { FutureError } from './errors/FutureError.mjs';
+export { IllegalArgumentsError } from './errors/IllegalArgumentsError.mjs';
+export { InvalidType } from './errors/InvalidType.mjs';
+export { InvalidValue } from './errors/InvalidValue.mjs';
+export { MissingArgumentsError } from './errors/MissingArgumentsError.mjs';
+export { NetworkError } from './errors/NetworkError.mjs';
+export { NoSuchElement } from './errors/NoSuchElement.mjs';
+export { NotImplemented } from './errors/NotImplemented.mjs';
+export { ParsingError } from './errors/ParsingError.mjs';
+export { QueueEmptyError } from './errors/QueueEmptyError.mjs';
+export { StackEmptyError } from './errors/StackEmptyError.mjs';
+export { StreamEnded } from './errors/StreamEnded.mjs';
+export { TimeoutError } from './errors/TimeoutError.mjs';
+export { VerificationError } from './errors/VerificationError.mjs';
+export { StackFullError } from './errors/StackFullError.mjs';

package/files.cjs

@@ -0,0 +1,201 @@
+'use strict';
+
+var _tslib = require('./_virtual/_tslib.cjs');
+var fs = require('fs');
+var readline = require('readline');
+var stream = require('./stream.cjs');
+var future = require('./future/future.cjs');
+var R = require('ramda');
+var path = require('path');
+require('./data-structures/object/WatchableObject.cjs');
+require('object-hash');
+require('uuid');
+var Queue = require('./data-structures/object/Queue.cjs');
+
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var readline__namespace = /*#__PURE__*/_interopNamespaceDefault(readline);
+
+class Files {
+    static watch(source, { objectMaxSize, expiryPeriod }) {
+        return Files.watchData(source, { objectMaxSize, expiryPeriod, encoding: "utf-8" });
+    }
+    static watchBinary(source, { objectMaxSize, expiryPeriod }) {
+        return Files.watchData(source, { objectMaxSize, expiryPeriod, encoding: "binary" });
+    }
+    static removeDirectories(source) {
+        return future.Future.of((resolve, reject) => {
+            fs.rm(source, { recursive: true, force: true }, (error) => (error ? reject(error) : resolve()));
+        });
+    }
+    static remove(source) {
+        return future.Future.of((resolve, reject) => {
+            fs.rm(source, (error) => (error ? reject(error) : resolve()));
+        });
+    }
+    static createDirectories(path) {
+        return future.Future.of((resolve, reject) => {
+            fs.mkdir(path, { recursive: true }, (error) => (error ? reject(error) : resolve()));
+        });
+    }
+    static list(path) {
+        return future.Future.of((resolve, reject, signal) => {
+            fs.readdir(path, { withFileTypes: true }, (error, files) => (error ? reject(error) : resolve(files)));
+        });
+    }
+    static move(source, dest, concurrencyLimit = 10) {
+        return Files.stat(source).thenApply(({ value }) => {
+            if (value.isFile()) {
+                return future.Future.of((resolve, reject) => fs.rename(source, dest, (error) => (error ? reject(error) : resolve())));
+            }
+            return Files.list(source)
+                .stream.flatten()
+                .parallel(concurrencyLimit)
+                .map((stat) => {
+                const oldPath = path.join(source, stat.name);
+                const newPath = path.join(dest, stat.name);
+                if (stat.isDirectory()) {
+                    return Files.move(oldPath, dest);
+                }
+                else if (stat.isFile()) {
+                    return future.Future.of((resolve, reject) => fs.rename(oldPath, newPath, (error) => (error ? reject(error) : resolve(null))));
+                }
+                return null;
+            })
+                .consume();
+        });
+    }
+    static stat(source) {
+        return future.Future.of((resolve, reject, signal) => {
+            fs.stat(source, (error, stat) => (error ? reject(error) : resolve(stat)));
+        });
+    }
+    static lines(source, encoding = "utf-8") {
+        let shutdownHook = () => { };
+        return stream.Stream.seed(() => {
+            const fileStream = fs.createReadStream(source, encoding);
+            const reader = readline__namespace.createInterface({
+                input: fileStream,
+                crlfDelay: Infinity,
+            });
+            shutdownHook = () => {
+                reader.close();
+                fileStream.close();
+            };
+            return stream.Stream.of(reader[Symbol.asyncIterator]());
+        }).onCompletion(() => shutdownHook());
+    }
+    static readNBytes(source, bufferSize) {
+        return Files.read(source, bufferSize).execute();
+    }
+    static read(source, bufferSize = 100) {
+        let shutdownHook = () => { };
+        return stream.Stream.seed(() => {
+            return future.Future.of((resolve, reject) => {
+                fs.open(source, "rb", function (error, fd) {
+                    shutdownHook = () => fs.close(fd);
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(fd);
+                });
+            }).stream.map((fd) => future.Future.of((resolve, reject, signal) => {
+                const buffer = Buffer.alloc(bufferSize);
+                fs.read(fd, buffer, 0, bufferSize, 0, function (error, num) {
+                    if (signal.aborted) {
+                        fs.close(fd, (err) => (err ? reject(err) : null));
+                        shutdownHook = () => { };
+                    }
+                    else if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(buffer);
+                    }
+                });
+            }));
+        }).onCompletion(() => shutdownHook());
+    }
+    static readString(source) {
+        return Files.readAll(source, "utf-8");
+    }
+    static readAll(source, encoding = null) {
+        return future.Future.of((resolve, reject, signal) => {
+            fs.readFile(source, { encoding, signal }, (error, data) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    static write(data, source, encoding = "utf-8") {
+        if (data instanceof stream.Stream) {
+            return Files.writeFromStream(data, source, encoding);
+        }
+        return future.Future.of((resolve, reject, signal) => {
+            fs.writeFile(source, data, { encoding, signal }, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    static writeFromStream(stream, source, encoding = "utf-8") {
+        return future.Future.of((resolve, reject, signal) => _tslib.__awaiter(this, void 0, void 0, function* () {
+            const fileStream = fs.createWriteStream(source, encoding);
+            yield stream
+                .map((v) => future.Future.of((resolve, reject) => {
+                if (!fileStream.write(v, (error) => {
+                    if (error) {
+                        fileStream.close();
+                        reject(error);
+                    }
+                })) {
+                    fileStream.once("drain", resolve);
+                }
+                else {
+                    resolve(null);
+                }
+            }))
+                .onCompletion(() => {
+                fileStream.close();
+            })
+                .cancelOnSignal(signal)
+                .consume();
+        }));
+    }
+    static watchData(source, { objectMaxSize, expiryPeriod, encoding }) {
+        const getQueue = R.once((signal) => {
+            const queue = new Queue.Queue(objectMaxSize, expiryPeriod);
+            fs.watch(source, { recursive: true, persistent: true, signal, encoding }, (v) => queue.enqueue(v));
+            return queue;
+        });
+        return new stream.Stream((signal) => {
+            const queue = getQueue(signal);
+            return queue.awaitDequeue(signal);
+        });
+    }
+}
+
+exports.Files = Files;

package/files.d.ts

@@ -0,0 +1,31 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import fs, { PathLike } from "fs";
+import { Stream } from "./stream";
+import { Future, WaitPeriod } from "./future";
+import { BufferEncoding } from "object-hash";
+interface FileWatchOptions {
+    encoding: BufferEncoding;
+    objectMaxSize?: number;
+    expiryPeriod?: WaitPeriod;
+}
+export declare class Files {
+    static watch(source: PathLike, { objectMaxSize, expiryPeriod }: Omit<FileWatchOptions, "encoding">): Stream<string>;
+    static watchBinary(source: PathLike, { objectMaxSize, expiryPeriod }: Omit<FileWatchOptions, "encoding">): Stream<Buffer>;
+    static removeDirectories(source: PathLike): Future<void>;
+    static remove(source: PathLike): Future<void>;
+    static createDirectories(path: PathLike): Future<void>;
+    static list(path: PathLike): Future<fs.Dirent[]>;
+    static move(source: string, dest: string, concurrencyLimit?: number): Future<void>;
+    static stat(source: PathLike): Future<fs.Stats>;
+    static lines(source: PathLike, encoding?: BufferEncoding): Stream<string>;
+    static readNBytes(source: PathLike, bufferSize: number): Future<Buffer>;
+    static read(source: PathLike, bufferSize?: number): Stream<Buffer>;
+    static readString(source: PathLike): Future<string>;
+    static readAll(source: PathLike, encoding?: BufferEncoding | null): Future<string | Buffer>;
+    static write(data: string | NodeJS.ArrayBufferView | Stream<string | NodeJS.ArrayBufferView>, source: PathLike, encoding?: BufferEncoding): Future<void>;
+    private static writeFromStream;
+    private static watchData;
+}
+export {};

package/files.mjs

@@ -0,0 +1,180 @@
+import { __awaiter } from './_virtual/_tslib.mjs';
+import fs from 'fs';
+import * as readline from 'readline';
+import { Stream } from './stream.mjs';
+import { Future } from './future/future.mjs';
+import R__default from 'ramda';
+import path from 'path';
+import './data-structures/object/WatchableObject.mjs';
+import 'object-hash';
+import 'uuid';
+import { Queue } from './data-structures/object/Queue.mjs';
+
+class Files {
+    static watch(source, { objectMaxSize, expiryPeriod }) {
+        return Files.watchData(source, { objectMaxSize, expiryPeriod, encoding: "utf-8" });
+    }
+    static watchBinary(source, { objectMaxSize, expiryPeriod }) {
+        return Files.watchData(source, { objectMaxSize, expiryPeriod, encoding: "binary" });
+    }
+    static removeDirectories(source) {
+        return Future.of((resolve, reject) => {
+            fs.rm(source, { recursive: true, force: true }, (error) => (error ? reject(error) : resolve()));
+        });
+    }
+    static remove(source) {
+        return Future.of((resolve, reject) => {
+            fs.rm(source, (error) => (error ? reject(error) : resolve()));
+        });
+    }
+    static createDirectories(path) {
+        return Future.of((resolve, reject) => {
+            fs.mkdir(path, { recursive: true }, (error) => (error ? reject(error) : resolve()));
+        });
+    }
+    static list(path) {
+        return Future.of((resolve, reject, signal) => {
+            fs.readdir(path, { withFileTypes: true }, (error, files) => (error ? reject(error) : resolve(files)));
+        });
+    }
+    static move(source, dest, concurrencyLimit = 10) {
+        return Files.stat(source).thenApply(({ value }) => {
+            if (value.isFile()) {
+                return Future.of((resolve, reject) => fs.rename(source, dest, (error) => (error ? reject(error) : resolve())));
+            }
+            return Files.list(source)
+                .stream.flatten()
+                .parallel(concurrencyLimit)
+                .map((stat) => {
+                const oldPath = path.join(source, stat.name);
+                const newPath = path.join(dest, stat.name);
+                if (stat.isDirectory()) {
+                    return Files.move(oldPath, dest);
+                }
+                else if (stat.isFile()) {
+                    return Future.of((resolve, reject) => fs.rename(oldPath, newPath, (error) => (error ? reject(error) : resolve(null))));
+                }
+                return null;
+            })
+                .consume();
+        });
+    }
+    static stat(source) {
+        return Future.of((resolve, reject, signal) => {
+            fs.stat(source, (error, stat) => (error ? reject(error) : resolve(stat)));
+        });
+    }
+    static lines(source, encoding = "utf-8") {
+        let shutdownHook = () => { };
+        return Stream.seed(() => {
+            const fileStream = fs.createReadStream(source, encoding);
+            const reader = readline.createInterface({
+                input: fileStream,
+                crlfDelay: Infinity,
+            });
+            shutdownHook = () => {
+                reader.close();
+                fileStream.close();
+            };
+            return Stream.of(reader[Symbol.asyncIterator]());
+        }).onCompletion(() => shutdownHook());
+    }
+    static readNBytes(source, bufferSize) {
+        return Files.read(source, bufferSize).execute();
+    }
+    static read(source, bufferSize = 100) {
+        let shutdownHook = () => { };
+        return Stream.seed(() => {
+            return Future.of((resolve, reject) => {
+                fs.open(source, "rb", function (error, fd) {
+                    shutdownHook = () => fs.close(fd);
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(fd);
+                });
+            }).stream.map((fd) => Future.of((resolve, reject, signal) => {
+                const buffer = Buffer.alloc(bufferSize);
+                fs.read(fd, buffer, 0, bufferSize, 0, function (error, num) {
+                    if (signal.aborted) {
+                        fs.close(fd, (err) => (err ? reject(err) : null));
+                        shutdownHook = () => { };
+                    }
+                    else if (error) {
+                        reject(error);
+                    }
+                    else {
+                        resolve(buffer);
+                    }
+                });
+            }));
+        }).onCompletion(() => shutdownHook());
+    }
+    static readString(source) {
+        return Files.readAll(source, "utf-8");
+    }
+    static readAll(source, encoding = null) {
+        return Future.of((resolve, reject, signal) => {
+            fs.readFile(source, { encoding, signal }, (error, data) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(data);
+                }
+            });
+        });
+    }
+    static write(data, source, encoding = "utf-8") {
+        if (data instanceof Stream) {
+            return Files.writeFromStream(data, source, encoding);
+        }
+        return Future.of((resolve, reject, signal) => {
+            fs.writeFile(source, data, { encoding, signal }, (error) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve();
+                }
+            });
+        });
+    }
+    static writeFromStream(stream, source, encoding = "utf-8") {
+        return Future.of((resolve, reject, signal) => __awaiter(this, void 0, void 0, function* () {
+            const fileStream = fs.createWriteStream(source, encoding);
+            yield stream
+                .map((v) => Future.of((resolve, reject) => {
+                if (!fileStream.write(v, (error) => {
+                    if (error) {
+                        fileStream.close();
+                        reject(error);
+                    }
+                })) {
+                    fileStream.once("drain", resolve);
+                }
+                else {
+                    resolve(null);
+                }
+            }))
+                .onCompletion(() => {
+                fileStream.close();
+            })
+                .cancelOnSignal(signal)
+                .consume();
+        }));
+    }
+    static watchData(source, { objectMaxSize, expiryPeriod, encoding }) {
+        const getQueue = R__default.once((signal) => {
+            const queue = new Queue(objectMaxSize, expiryPeriod);
+            fs.watch(source, { recursive: true, persistent: true, signal, encoding }, (v) => queue.enqueue(v));
+            return queue;
+        });
+        return new Stream((signal) => {
+            const queue = getQueue(signal);
+            return queue.awaitDequeue(signal);
+        });
+    }
+}
+
+export { Files };