Import other modules into monorepo

src/util/support/path.ts

@@ -0,0 +1,348 @@
+import * as nodePath from 'path'
+import * as fs from 'fs'
+import * as mkdirp from 'mkdirp'
+import { Filesystem } from "./path/Filesystem"
+import ReadableStream = NodeJS.ReadableStream;
+import WritableStream = NodeJS.WritableStream;
+
+/**
+ * Possible prefixes for files referenced by a UniversalPath.
+ */
+export enum UniversalPathPrefix {
+    HTTP = 'http://',
+    HTTPS = 'https://',
+    Local = 'file://',
+}
+
+/**
+ * An item that could represent a path.
+ */
+export type PathLike = string | UniversalPath
+
+/**
+ * Create a new UniversalPath from the given path-like segments.
+ * @param parts
+ */
+export function universalPath(...parts: PathLike[]): UniversalPath {
+    let [main, ...concats] = parts
+    if ( !(main instanceof UniversalPath) ) main = new UniversalPath(main)
+    return main.concat(...concats)
+}
+
+/**
+ * Walk recursively over entries in a directory.
+ *
+ * Right now the types are kinda weird for async iterables. This is like an async
+ * IterableIterable that resolves a string or another IterableIterable of the same type.
+ *
+ * Hence why it's separate from the UniversalPath class.
+ *
+ * @param dir
+ */
+export async function* walk(dir: string): any {
+    for await (const sub of await fs.promises.opendir(dir) ) {
+        const entry = nodePath.join(dir, sub.name)
+        if ( sub.isDirectory() ) yield* walk(entry)
+        else if ( sub.isFile() ) yield entry
+    }
+}
+
+/**
+ * Class representing some kind of filesystem resource.
+ */
+export class UniversalPath {
+    protected _prefix!: string
+    protected _local!: string
+
+    constructor(
+        /**
+         * The path string this path refers to.
+         *
+         * @example /home/user/file.txt
+         * @example https://site.com/file.txt
+         */
+        protected readonly initial: string,
+        protected readonly filesystem?: Filesystem,
+    ) {
+        this.setPrefix()
+        this.setLocal()
+    }
+
+    /**
+     * Determine the correct prefix for this path.
+     * @protected
+     */
+    protected setPrefix() {
+        if ( this.initial.toLowerCase().startsWith('http://') ) {
+            this._prefix = UniversalPathPrefix.HTTP
+        } else if ( this.initial.toLowerCase().startsWith('https://') ) {
+            this._prefix = UniversalPathPrefix.HTTPS
+        } else if ( this.filesystem ) {
+            this._prefix = this.filesystem.getPrefix()
+        } else {
+            this._prefix = UniversalPathPrefix.Local
+        }
+    }
+
+    /**
+     * Determine the "localized" string of this path.
+     *
+     * This is the normalized path WITHOUT the prefix.
+     *
+     * @example
+     * The normalized path of "file:///home/user/file.txt" is "/home/user/file.txt".
+     *
+     * @protected
+     */
+    protected setLocal() {
+        this._local = this.initial
+        if ( this.initial.toLowerCase().startsWith(this._prefix) ) {
+            this._local = this._local.slice(this._prefix.length)
+        }
+
+        if ( this._prefix === UniversalPathPrefix.Local && !this._local.startsWith('/') && !this.filesystem ) {
+            this._local = nodePath.resolve(this._local)
+        }
+    }
+
+    /**
+     * Return a new copy of this UniversalPath instance.
+     */
+    clone() {
+        return new UniversalPath(this.initial)
+    }
+
+    /**
+     * Get the UniversalPathPrefix of this resource.
+     */
+    get prefix() {
+        return this._prefix
+    }
+
+    /**
+     * Returns true if this resource refers to a file on the local filesystem.
+     */
+    get isLocal() {
+        return this._prefix === UniversalPathPrefix.Local && !this.filesystem
+    }
+
+    /**
+     * Returns true if this resource refers to a file on a remote filesystem.
+     */
+    get isRemote() {
+        return this._prefix !== UniversalPathPrefix.Local || this.filesystem
+    }
+
+    /**
+     * Get the non-prefixed path to this resource.
+     */
+    get unqualified() {
+        return this._local
+    }
+
+    /**
+     * Get the path to this resource as it would be accessed from the current filesystem.
+     */
+    get toLocal() {
+        if ( this.isLocal ) {
+            return this._local
+        } else {
+            return `${this.prefix}${this._local}`
+        }
+    }
+
+    /**
+     * Get the fully-prefixed path to this resource.
+     */
+    get toRemote() {
+        return `${this.prefix}${this._local}`
+    }
+
+    /**
+     * Append and resolve the given paths to this resource and return a new UniversalPath.
+     *
+     * @example
+     * ```typescript
+     * const homeDir = universalPath('home', 'user')
+     *
+     * homeDir.concat('file.txt').toLocal  // => /home/user/file.txt
+     *
+     * homeDir.concat('..', 'other_user').toLocal  // => /home/other_user
+     * ```
+     *
+     * @param paths
+     */
+    public concat(...paths: PathLike[]): UniversalPath {
+        const resolved = nodePath.join(this.unqualified, ...(paths.map(p => typeof p === 'string' ? p : p.unqualified)))
+        return new UniversalPath(`${this.prefix}${resolved}`)
+    }
+
+    /**
+     * Append the given path-like item to this resource's path.
+     * Unlike `concat`, this mutates the current instance.
+     * @param path
+     */
+    public append(path: PathLike): this {
+        this._local += String(path)
+        return this
+    }
+
+    /**
+     * Cast the path to a string (fully-prefixed).
+     */
+    toString() {
+        return `${this.prefix}${this._local}`
+    }
+
+    /**
+     * Get the extension of the resource referred to by this instance.
+     *
+     * @example
+     * ```typescript
+     * const myFile = universalPath('home', 'user', 'file.txt')
+     *
+     * myFile.ext  // => 'txt'
+     * ```
+     */
+    get ext() {
+        return nodePath.extname(this._local)
+    }
+
+    /**
+     * Recursively walk all files in this directory. Must be a local resource.
+     *
+     * This returns an async generator function.
+     *
+     * @example
+     * ```typescript
+     * const configFiles = universalPath('home', 'user', '.config')
+     *
+     * for await (const configFile of configFiles.walk()) {
+     *     // configFile is a string
+     *     // ... do something ...
+     * }
+     * ```
+     */
+    walk() {
+        return walk(this._local)
+    }
+
+    /**
+     * Returns true if the given resource exists at the path.
+     */
+    async exists() {
+        if ( this.filesystem ) {
+            const stat = await this.filesystem.stat({
+                storePath: this._local
+            })
+
+            return stat.exists
+        }
+
+        try {
+            await fs.promises.stat(this._local)
+            return true
+        } catch(e) {
+            return false
+        }
+    }
+
+    /**
+     * Recursively create this path as a directory. Equivalent to `mkdir -p` on Linux.
+     */
+    async mkdir() {
+        if ( this.filesystem ) {
+            await this.filesystem.mkdir({
+                storePath: this._local
+            })
+        } else {
+            await mkdirp(this._local)
+        }
+    }
+
+    /**
+     * Write the given data to this resource as a file.
+     * @param data
+     */
+    async write(data: string | Buffer) {
+        if ( typeof data === 'string' ) data = Buffer.from(data, 'utf8')
+
+        if ( this.filesystem ) {
+            const stream = await this.filesystem.putStoreFileAsStream({
+                storePath: this._local
+            })
+
+            await new Promise<void>((res, rej) => {
+                stream.write(data, err => {
+                    if ( err ) rej(err)
+                    else res()
+                })
+            })
+        } else {
+            const fd = await fs.promises.open(this._local, 'w')
+            await fd.write(data)
+            await fd.close()
+        }
+    }
+
+    /**
+     * Get a writable stream to this file's contents.
+     */
+    async writeStream(): Promise<WritableStream> {
+        if ( this.filesystem ) {
+            return this.filesystem.putStoreFileAsStream({
+                storePath: this._local
+            })
+        } else {
+            return fs.createWriteStream(this._local)
+        }
+    }
+
+    /**
+     * Read the data from this resource's file as a string.
+     */
+    async read() {
+        let stream: ReadableStream
+        if ( this.filesystem ) {
+            stream = await this.filesystem.getStoreFileAsStream({
+                storePath: this._local
+            })
+        } else {
+            stream = fs.createReadStream(this._local)
+        }
+
+        const chunks: any[] = []
+        return new Promise<string>((res, rej) => {
+            stream.on('data', chunk => chunks.push(Buffer.from(chunk)))
+            stream.on('error', rej)
+            stream.on('end', () => res(Buffer.concat(chunks).toString('utf-8')))
+        })
+    }
+
+    /**
+     * Get a readable stream of this file's contents.
+     */
+    async readStream(): Promise<ReadableStream> {
+        if ( this.filesystem ) {
+            return this.filesystem.getStoreFileAsStream({
+                storePath: this._local
+            })
+        } else {
+            return fs.createReadStream(this._local)
+        }
+    }
+
+    /*get mime_type() {
+        return Mime.lookup(this.ext)
+    }
+
+    get content_type() {
+        return Mime.contentType(this.ext)
+    }
+
+    get charset() {
+        if ( this.mime_type ) {
+            return Mime.charset(this.mime_type)
+        }
+    }*/
+}