cspell-io 7.3.8 → 8.0.0

package/dist/esm/CSpellIONode.js

@@ -6,6 +6,7 @@ import { toURL, urlBasename, urlDirname } from './node/file/util.js';
 import { RequestFsReadFile, RequestFsReadFileSync, RequestFsStat, RequestFsStatSync, RequestFsWriteFile, } from './requests/index.js';
 let defaultCSpellIONode = undefined;
 export class CSpellIONode {
+    serviceBus;
     constructor(serviceBus = new ServiceBus()) {
         this.serviceBus = serviceBus;
         registerHandlers(serviceBus);

package/dist/esm/errors/ErrorNotImplemented.js

@@ -1,4 +1,5 @@
 export class ErrorNotImplemented extends Error {
+    method;
     constructor(method) {
         super(`Method ${method} is not supported.`);
         this.method = method;

package/dist/esm/node/file/FetchError.d.ts

@@ -5,5 +5,14 @@ export declare class FetchUrlError extends Error implements NodeJS.ErrnoExceptio
     readonly url: URL;
     constructor(message: string, code: string | undefined, status: number | undefined, url: URL);
     static create(url: URL, status: number, message?: string): FetchUrlError;
+    static fromError(url: URL, e: Error): FetchUrlError;
 }
+export declare function isNodeError(e: unknown): e is NodeJS.ErrnoException;
+export declare function isError(e: unknown): e is Error;
+interface ErrorWithOptionalCause extends Error {
+    cause?: NodeJS.ErrnoException;
+}
+export declare function isErrorWithOptionalCause(e: unknown): e is ErrorWithOptionalCause;
+export declare function getCause(e: unknown): NodeJS.ErrnoException | undefined;
+export {};
 //# sourceMappingURL=FetchError.d.ts.map

package/dist/esm/node/file/FetchError.js

@@ -1,4 +1,7 @@
 export class FetchUrlError extends Error {
+    code;
+    status;
+    url;
     constructor(message, code, status, url) {
         super(message);
         this.code = code;
@@ -13,5 +16,31 @@ export class FetchUrlError extends Error {
             return new FetchUrlError(message || 'Permission denied.', 'EACCES', status, url);
         return new FetchUrlError(message || 'Fatal Error', 'ECONNREFUSED', status, url);
     }
+    static fromError(url, e) {
+        const cause = getCause(e);
+        if (cause) {
+            return new FetchUrlError(cause.message, cause.code, undefined, url);
+        }
+        if (isNodeError(e)) {
+            return new FetchUrlError(e.message, e.code, undefined, url);
+        }
+        return new FetchUrlError(e.message, undefined, undefined, url);
+    }
+}
+export function isNodeError(e) {
+    if (e instanceof Error && 'code' in e && typeof e.code === 'string')
+        return true;
+    if (e && typeof e === 'object' && 'code' in e && typeof e.code === 'string')
+        return true;
+    return false;
+}
+export function isError(e) {
+    return e instanceof Error;
+}
+export function isErrorWithOptionalCause(e) {
+    return !!e && typeof e === 'object' && 'cause' in e && isNodeError(e.cause);
+}
+export function getCause(e) {
+    return isErrorWithOptionalCause(e) ? e.cause : undefined;
 }
 //# sourceMappingURL=FetchError.js.map

package/dist/esm/node/file/fetch.d.ts

@@ -1,6 +1,4 @@
 /// <reference types="node" resolution-mode="require"/>
-import type { Headers, RequestInit, Response } from 'node-fetch';
 export declare function fetchHead(request: string | URL): Promise<Headers>;
 export declare function fetchURL(url: URL): Promise<Buffer>;
-export declare function fetch(url: string | URL, init?: RequestInit): Promise<Response>;
 //# sourceMappingURL=fetch.d.ts.map

package/dist/esm/node/file/fetch.js

@@ -1,19 +1,37 @@
-import nodeFetch from 'node-fetch';
-import { FetchUrlError } from './FetchError.js';
+import { FetchUrlError, isError } from './FetchError.js';
 export async function fetchHead(request) {
-    const r = await fetch(request, { method: 'HEAD' });
-    return r.headers;
+    const url = toURL(request);
+    try {
+        const r = await fetch(url, { method: 'HEAD' });
+        return r.headers;
+    }
+    catch (e) {
+        console.warn('fetchHead Error %o', e);
+        if (isError(e)) {
+            throw FetchUrlError.fromError(url, e);
+        }
+        throw e;
+    }
 }
 export async function fetchURL(url) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw FetchUrlError.create(url, response.status);
+    try {
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw FetchUrlError.create(url, response.status);
+        }
+        return Buffer.from(await response.arrayBuffer());
+    }
+    catch (e) {
+        // console.warn('fetchURL Error %o', e);
+        if (e instanceof FetchUrlError)
+            throw e;
+        if (isError(e)) {
+            throw FetchUrlError.fromError(url, e);
+        }
+        throw e;
     }
-    return Buffer.from(await response.arrayBuffer());
 }
-export function fetch(url, init) {
-    /// This is a n issue with how TypeScript handles packages without `type` being set.
-    // @ts-ignore
-    return nodeFetch(url, init);
+function toURL(url) {
+    return typeof url === 'string' ? new URL(url) : url;
 }
 //# sourceMappingURL=fetch.js.map

package/dist/esm/node/file/fileReader.js

@@ -7,8 +7,7 @@ import { promisify } from 'util';
 import * as zlib from 'zlib';
 import { decode } from '../../common/encode-decode.js';
 import { createDecoderTransformer } from '../../common/transformers.js';
-import { fetch } from './fetch.js';
-import { FetchUrlError } from './FetchError.js';
+import { fetchURL } from './fetch.js';
 import { isFileURL, isSupportedURL, isZipped, toURL } from './util.js';
 const defaultEncoding = 'utf8';
 const pipeline = promisify(Stream.pipeline);
@@ -25,11 +24,8 @@ function _readFileText(url, encoding) {
     return _readText(() => fs.createReadStream(filename), isZipped(filename), encoding);
 }
 async function _fetchTextFromURL(url, encoding) {
-    const response = await fetch(url);
-    if (!response.ok) {
-        throw FetchUrlError.create(url, response.status);
-    }
-    return _readText(() => response.body, isZipped(url), encoding);
+    const buffer = await fetchURL(url);
+    return _readText(() => Stream.Readable.from(buffer), isZipped(url), encoding);
 }
 async function _readText(getStream, isZipped, encoding) {
     const stream = getStream();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cspell-io",
-  "version": "7.3.8",
+  "version": "8.0.0",
   "description": "A library of useful I/O functions used across various cspell tools.",
   "type": "module",
   "types": "dist/esm/index.d.ts",
@@ -43,16 +43,14 @@
   },
   "homepage": "https://github.com/streetsidesoftware/cspell#readme",
   "engines": {
-    "node": ">=16"
+    "node": ">=18"
   },
   "devDependencies": {
-    "@types/node-fetch": "^2.6.6",
     "lorem-ipsum": "^2.0.8",
     "typescript": "^5.2.2"
   },
   "dependencies": {
-    "@cspell/cspell-service-bus": "7.3.8",
-    "node-fetch": "^2.7.0"
+    "@cspell/cspell-service-bus": "8.0.0"
   },
-  "gitHead": "6717f5726b74c695d9023dbccf6f7e8a7ac6361f"
+  "gitHead": "67c22bf98baed1c17bbc658fba8656262d17e370"
 }