@gjsify/fetch 0.0.2

package/src/utils/blob-from.ts

@@ -0,0 +1,168 @@
+import { DOMException } from "@gjsify/deno-runtime/ext/web/01_dom_exception";
+import { Blob, File } from "@gjsify/deno-runtime/ext/web/09_file";
+
+import {
+    realpathSync,
+    statSync,
+    rmdirSync,
+    createReadStream,
+    promises as fs
+} from 'node:fs'
+import { basename, sep, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import process from 'node:process'
+
+// import Blob from './index.js'
+
+const { stat, mkdtemp } = fs
+let i = 0, tempDir, registry
+
+/**
+ * @param {string} path filepath on the disk
+ * @param {string} [type] mimetype to use
+ */
+const blobFromSync = (path: string, type: string) => fromBlob(statSync(path), path, type)
+
+/**
+ * @param {string} path filepath on the disk
+ * @param {string} [type] mimetype to use
+ * @returns {Promise<Blob>}
+ */
+const blobFrom = (path: string, type: string): Promise<Blob> => stat(path).then(stat => fromBlob(stat, path, type))
+
+/**
+ * @param {string} path filepath on the disk
+ * @param {string} [type] mimetype to use
+ * @returns {Promise<File>}
+ */
+const fileFrom = (path: string, type: string): Promise<File> => stat(path).then(stat => fromFile(stat, path, type))
+
+/**
+ * @param {string} path filepath on the disk
+ * @param {string} [type] mimetype to use
+ */
+const fileFromSync = (path: string, type: string) => fromFile(statSync(path), path, type)
+
+// @ts-ignore
+const fromBlob = (stat, path, type = '') => new Blob([new BlobDataItem({
+    path,
+    size: stat.size,
+    lastModified: stat.mtimeMs,
+    start: 0
+})], { type })
+
+// @ts-ignore
+const fromFile = (stat, path, type = '') => new File([new BlobDataItem({
+    path,
+    size: stat.size,
+    lastModified: stat.mtimeMs,
+    start: 0
+})], basename(path), { type, lastModified: stat.mtimeMs })
+
+/**
+ * Creates a temporary blob backed by the filesystem.
+ * NOTE: requires node.js v14 or higher to use FinalizationRegistry
+ *
+ * @param {*} data Same as fs.writeFile data
+ * @param {BlobPropertyBag & {signal?: AbortSignal}} options
+ * @param {AbortSignal} [signal] in case you wish to cancel the write operation
+ * @returns {Promise<Blob>}
+ */
+const createTemporaryBlob = async (data: any, { signal, type }: BlobPropertyBag & { signal?: AbortSignal; } = {}): Promise<Blob> => {
+    registry = registry || new FinalizationRegistry(fs.unlink)
+    tempDir = tempDir || await mkdtemp(realpathSync(tmpdir()) + sep)
+    const id = `${i++}`
+    const destination = join(tempDir, id)
+    if (data instanceof ArrayBuffer) data = new Uint8Array(data)
+    await fs.writeFile(destination, data, { signal })
+    const blob = await blobFrom(destination, type)
+    registry.register(blob, destination)
+    return blob
+}
+
+/**
+ * Creates a temporary File backed by the filesystem.
+ * Pretty much the same as constructing a new File(data, name, options)
+ *
+ * NOTE: requires node.js v14 or higher to use FinalizationRegistry
+ * @param {*} data
+ * @param {string} name
+ * @param {FilePropertyBag & {signal?: AbortSignal}} opts
+ * @returns {Promise<File>}
+ */
+const createTemporaryFile = async (data: any, name: string, opts: FilePropertyBag & { signal?: AbortSignal; }): Promise<File> => {
+    const blob = await createTemporaryBlob(data)
+    return new File([blob], name, opts)
+}
+
+/**
+ * This is a blob backed up by a file on the disk
+ * with minium requirement. Its wrapped around a Blob as a blobPart
+ * so you have no direct access to this.
+ *
+ * @private
+ */
+class BlobDataItem {
+    #path: string;
+    #start: number;
+    size
+    lastModified
+    originalSize
+
+    constructor(options) {
+        this.#path = options.path
+        this.#start = options.start
+        this.size = options.size
+        this.lastModified = options.lastModified
+        this.originalSize = options.originalSize === undefined
+            ? options.size
+            : options.originalSize
+    }
+
+    /**
+     * Slicing arguments is first validated and formatted
+     * to not be out of range by Blob.prototype.slice
+     */
+    slice(start: number, end: number) {
+        return new BlobDataItem({
+            path: this.#path,
+            lastModified: this.lastModified,
+            originalSize: this.originalSize,
+            size: end - start,
+            start: this.#start + start
+        })
+    }
+
+    async * stream() {
+        const { mtimeMs, size } = await stat(this.#path)
+
+        if (mtimeMs > this.lastModified || this.originalSize !== size) {
+            throw new DOMException('The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.', 'NotReadableError')
+        }
+
+        yield* createReadStream(this.#path, {
+            start: this.#start,
+            end: this.#start + this.size - 1
+        })
+    }
+
+    get [Symbol.toStringTag]() {
+        return 'Blob'
+    }
+}
+
+process.once('exit', () => {
+    tempDir && rmdirSync(tempDir, { recursive: true })
+})
+
+export default blobFromSync
+export {
+    Blob,
+    blobFrom,
+    blobFromSync,
+    createTemporaryBlob,
+    File,
+    fileFrom,
+    fileFromSync,
+    createTemporaryFile
+}

package/src/utils/get-search.ts

@@ -0,0 +1,9 @@
+export const getSearch = (parsedURL: URL) => {
+	if (parsedURL.search) {
+		return parsedURL.search;
+	}
+
+	const lastOffset = parsedURL.href.length - 1;
+	const hash = parsedURL.hash || (parsedURL.href[lastOffset] === '#' ? '#' : '');
+	return parsedURL.href[lastOffset - hash.length] === '?' ? '?' : '';
+};

package/src/utils/is-redirect.ts

@@ -0,0 +1,11 @@
+const redirectStatus = new Set([301, 302, 303, 307, 308]);
+
+/**
+ * Redirect code matching
+ *
+ * @param {number} code - Status code
+ * @return {boolean}
+ */
+export const isRedirect = code => {
+	return redirectStatus.has(code);
+};

package/src/utils/is.ts

@@ -0,0 +1,88 @@
+import { URL } from '@gjsify/deno-runtime/ext/url/00_url';
+import { Blob } from "@gjsify/deno-runtime/ext/web/09_file";
+
+/**
+ * Is.js
+ *
+ * Object type checks.
+ */
+
+const NAME = Symbol.toStringTag;
+
+/**
+ * Check if `obj` is a URLSearchParams object
+ * ref: https://github.com/node-fetch/node-fetch/issues/296#issuecomment-307598143
+ * @param {*} object - Object to check for
+ * @return {boolean}
+ */
+export const isURLSearchParameters = object => {
+	return (
+		typeof object === 'object' &&
+		typeof object.append === 'function' &&
+		typeof object.delete === 'function' &&
+		typeof object.get === 'function' &&
+		typeof object.getAll === 'function' &&
+		typeof object.has === 'function' &&
+		typeof object.set === 'function' &&
+		typeof object.sort === 'function' &&
+		object[NAME] === 'URLSearchParams'
+	);
+};
+
+/**
+ * Check if `object` is a W3C `Blob` object (which `File` inherits from)
+ * @param object Object to check for
+ */
+export const isBlob = (value: any): value is Blob => {
+	return (
+		value &&
+		typeof value === 'object' &&
+		typeof value.arrayBuffer === 'function' &&
+		typeof value.type === 'string' &&
+		typeof value.stream === 'function' &&
+		typeof value.constructor === 'function' &&
+		/^(Blob|File)$/.test(value[NAME])
+	);
+};
+
+/**
+ * Check if `obj` is an instance of AbortSignal.
+ * @param object - Object to check for
+ */
+export const isAbortSignal = (object: any) => {
+	return (
+		typeof object === 'object' && (
+			object[NAME] === 'AbortSignal' ||
+			object[NAME] === 'EventTarget'
+		)
+	);
+};
+
+/**
+ * isDomainOrSubdomain reports whether sub is a subdomain (or exact match) of
+ * the parent domain.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+export const isDomainOrSubdomain = (destination, original) => {
+	const orig = new URL(original).hostname;
+	const dest = new URL(destination).hostname;
+
+	return orig === dest || orig.endsWith(`.${dest}`);
+};
+
+/**
+ * isSameProtocol reports whether the two provided URLs use the same protocol.
+ *
+ * Both domains must already be in canonical form.
+ * @param {string|URL} original
+ * @param {string|URL} destination
+ */
+export const isSameProtocol = (destination, original) => {
+	const orig = new URL(original).protocol;
+	const dest = new URL(destination).protocol;
+
+	return orig === dest;
+};