cspell-io 8.16.0 → 8.17.0

package/dist/esm/CSpellIO.d.ts

@@ -1,14 +1,19 @@
 import type { BufferEncoding } from './models/BufferEncoding.js';
 import type { FileReference, TextFileResource, UrlOrFilename, UrlOrReference } from './models/FileResource.js';
 import type { DirEntry, Stats } from './models/index.js';
+export interface ReadFileOptions {
+    signal?: AbortSignal;
+    encoding?: BufferEncoding;
+}
+export type ReadFileOptionsOrEncoding = ReadFileOptions | BufferEncoding;
 export interface CSpellIO {
     /**
      * Read a file
      * @param urlOrFilename - uri of the file to read
-     * @param encoding - optional encoding.
+     * @param options - optional options for reading the file.
      * @returns A TextFileResource.
      */
-    readFile(urlOrFilename: UrlOrReference, encoding?: BufferEncoding): Promise<TextFileResource>;
+    readFile(urlOrFilename: UrlOrReference, options?: ReadFileOptionsOrEncoding): Promise<TextFileResource>;
     /**
      * Read a file in Sync mode.
      * Note: `http` requests will fail.
@@ -88,4 +93,5 @@ export interface CSpellIO {
      */
     urlDirname(urlOrFilename: UrlOrReference): URL;
 }
+export declare function toReadFileOptions(options?: ReadFileOptionsOrEncoding): ReadFileOptions | undefined;
 //# sourceMappingURL=CSpellIO.d.ts.map

package/dist/esm/CSpellIO.js

@@ -1,2 +1,9 @@
-export {};
+export function toReadFileOptions(options) {
+    if (!options)
+        return options;
+    if (typeof options === 'string') {
+        return { encoding: options };
+    }
+    return options;
+}
 //# sourceMappingURL=CSpellIO.js.map

package/dist/esm/CSpellIONode.d.ts

@@ -1,10 +1,10 @@
 import { ServiceBus } from '@cspell/cspell-service-bus';
-import type { CSpellIO } from './CSpellIO.js';
+import type { CSpellIO, ReadFileOptionsOrEncoding } from './CSpellIO.js';
 import type { BufferEncoding, DirEntry, FileReference, Stats, TextFileResource, UrlOrReference } from './models/index.js';
 export declare class CSpellIONode implements CSpellIO {
     readonly serviceBus: ServiceBus;
     constructor(serviceBus?: ServiceBus);
-    readFile(urlOrFilename: UrlOrReference, encoding?: BufferEncoding): Promise<TextFileResource>;
+    readFile(urlOrFilename: UrlOrReference, options?: ReadFileOptionsOrEncoding): Promise<TextFileResource>;
     readDirectory(urlOrFilename: string | URL): Promise<DirEntry[]>;
     readFileSync(urlOrFilename: UrlOrReference, encoding?: BufferEncoding): TextFileResource;
     writeFile(urlOrFilename: UrlOrReference, content: string | ArrayBufferView): Promise<FileReference>;

package/dist/esm/CSpellIONode.js

@@ -1,7 +1,8 @@
 import { isServiceResponseSuccess, ServiceBus } from '@cspell/cspell-service-bus';
-import { isFileReference, toFileReference } from './common/CFileReference.js';
+import { isFileReference, toFileReference, toFileResourceRequest } from './common/CFileReference.js';
 import { CFileResource } from './common/CFileResource.js';
 import { compareStats } from './common/stat.js';
+import { toReadFileOptions } from './CSpellIO.js';
 import { ErrorNotImplemented } from './errors/errors.js';
 import { registerHandlers } from './handlers/node/file.js';
 import { toFileURL, toURL, urlBasename, urlDirname } from './node/file/url.js';
@@ -14,8 +15,9 @@ export class CSpellIONode {
         this.serviceBus = serviceBus;
         registerHandlers(serviceBus);
     }
-    readFile(urlOrFilename, encoding) {
-        const ref = toFileReference(urlOrFilename, encoding);
+    readFile(urlOrFilename, options) {
+        const readOptions = toReadFileOptions(options);
+        const ref = toFileResourceRequest(urlOrFilename, readOptions?.encoding, readOptions?.signal);
         const res = this.serviceBus.dispatch(RequestFsReadFile.create(ref));
         if (!isServiceResponseSuccess(res)) {
             throw genError(res.error, 'readFile');

package/dist/esm/CVirtualFS.js

@@ -118,7 +118,7 @@ function fsPassThroughCore(fs) {
         providerInfo: { name: 'default' },
         hasProvider: true,
         stat: async (url) => gfs(url, 'stat').stat(url),
-        readFile: async (url) => gfs(url, 'readFile').readFile(url),
+        readFile: async (url, options) => gfs(url, 'readFile').readFile(url, options),
         writeFile: async (file) => gfs(file, 'writeFile').writeFile(file),
         readDirectory: async (url) => gfs(url, 'readDirectory')
             .readDirectory(url)

package/dist/esm/VFileSystem.d.ts

@@ -13,6 +13,10 @@ export declare enum FSCapabilityFlags {
 export interface FileSystemProviderInfo {
     name: string;
 }
+export interface ReadFileOptions {
+    signal?: AbortSignal;
+    encoding?: BufferEncoding;
+}
 export interface VFileSystemCore {
     /**
      * Read a file.
@@ -20,7 +24,14 @@ export interface VFileSystemCore {
      * @param encoding - optional encoding
      * @returns A FileResource, the content will not be decoded. Use `.getText()` to get the decoded text.
      */
-    readFile(url: UrlOrReference, encoding?: BufferEncoding): Promise<TextFileResource>;
+    readFile(url: UrlOrReference, encoding: BufferEncoding): Promise<TextFileResource>;
+    /**
+     * Read a file.
+     * @param url - URL to read
+     * @param options - options for reading the file.
+     * @returns A FileResource, the content will not be decoded. Use `.getText()` to get the decoded text.
+     */
+    readFile(url: UrlOrReference, options?: ReadFileOptions | BufferEncoding): Promise<TextFileResource>;
     /**
      * Write a file
      * @param file - the file to write

package/dist/esm/VirtualFS/WrappedProviderFs.d.ts

@@ -2,8 +2,8 @@ import type { CSpellIO } from '../CSpellIO.js';
 import type { BufferEncoding, DirEntry, FileReference, FileResource, TextFileResource } from '../models/index.js';
 import { FileType } from '../models/index.js';
 import type { LogEvent } from '../models/LogEvent.js';
-import { FileSystemProviderInfo, FSCapabilities, FSCapabilityFlags, UrlOrReference, VFileSystemCore, VfsDirEntry, VfsStat } from '../VFileSystem.js';
-import { VFileSystemProvider, VProviderFileSystem } from '../VirtualFS.js';
+import { FileSystemProviderInfo, FSCapabilities, FSCapabilityFlags, ReadFileOptions, UrlOrReference, VFileSystemCore, VfsDirEntry, VfsStat } from '../VFileSystem.js';
+import type { VFileSystemProvider, VProviderFileSystem } from '../VirtualFS.js';
 export declare function cspellIOToFsProvider(cspellIO: CSpellIO): VFileSystemProvider;
 export declare class VFSError extends Error {
     constructor(message: string, options?: {
@@ -12,9 +12,9 @@ export declare class VFSError extends Error {
 }
 export declare class VFSErrorUnsupportedRequest extends VFSError {
     readonly request: string;
-    readonly parameters?: unknown;
+    readonly parameters?: unknown | undefined;
     readonly url?: string | undefined;
-    constructor(request: string, url?: URL | string, parameters?: unknown);
+    constructor(request: string, url?: URL | string, parameters?: unknown | undefined);
 }
 export declare function fsCapabilities(flags: FSCapabilityFlags): FSCapabilities;
 export declare class WrappedProviderFs implements VFileSystemCore {
@@ -28,7 +28,7 @@ export declare class WrappedProviderFs implements VFileSystemCore {
     private logEvent;
     getCapabilities(url: URL): FSCapabilities;
     stat(urlRef: UrlOrReference): Promise<VfsStat>;
-    readFile(urlRef: UrlOrReference, encoding?: BufferEncoding): Promise<TextFileResource>;
+    readFile(urlRef: UrlOrReference, optionsOrEncoding?: BufferEncoding | ReadFileOptions): Promise<TextFileResource>;
     readDirectory(url: URL): Promise<VfsDirEntry[]>;
     writeFile(file: FileResource): Promise<FileReference>;
     static disposeOf<V extends VFileSystemCore>(fs: V): void;

package/dist/esm/VirtualFS/WrappedProviderFs.js

@@ -14,7 +14,7 @@ export function cspellIOToFsProvider(cspellIO) {
     const fs = {
         providerInfo: { name },
         stat: (url) => cspellIO.getStat(url),
-        readFile: (url) => cspellIO.readFile(url),
+        readFile: (url, options) => cspellIO.readFile(url, options),
         readDirectory: (url) => cspellIO.readDirectory(url),
         writeFile: (file) => cspellIO.writeFile(file.url, file.content),
         dispose: () => undefined,
@@ -115,13 +115,14 @@ export class WrappedProviderFs {
             this.logEvent('stat', 'end', traceID, url);
         }
     }
-    async readFile(urlRef, encoding) {
+    async readFile(urlRef, optionsOrEncoding) {
         const traceID = performance.now();
         const url = urlOrReferenceToUrl(urlRef);
         this.logEvent('readFile', 'start', traceID, url);
         try {
             checkCapabilityOrThrow(this.fs, this.capabilities, FSCapabilityFlags.Read, 'readFile', url);
-            return createTextFileResource(await this.fs.readFile(urlRef), encoding);
+            const readOptions = toOptions(optionsOrEncoding);
+            return createTextFileResource(await this.fs.readFile(urlRef, readOptions), readOptions?.encoding);
         }
         catch (e) {
             this.logEvent('readFile', 'error', traceID, url, e instanceof Error ? e.message : '');
@@ -247,4 +248,7 @@ export function chopUrl(url) {
 export function rPad(str, len, ch = ' ') {
     return str.padEnd(len, ch);
 }
+function toOptions(val) {
+    return typeof val === 'string' ? { encoding: val } : val;
+}
 //# sourceMappingURL=WrappedProviderFs.js.map

package/dist/esm/VirtualFS/redirectProvider.js

@@ -93,9 +93,9 @@ function remapFS(name, fs, shadowFs, publicRoot, privateRoot, options) {
             const stat = await fs.stat(url2);
             return stat;
         },
-        readFile: async (url) => {
+        readFile: async (url, options) => {
             const url2 = mapUrlOrReferenceToPrivate(url);
-            const file = await fs.readFile(url2);
+            const file = await fs.readFile(url2, options);
             return mapFileResourceToPublic(file);
         },
         readDirectory: async (url) => {

package/dist/esm/VirtualFS.d.ts

@@ -26,8 +26,13 @@ export interface VirtualFS extends Disposable {
     loggingEnabled: boolean;
     enableLogging(value?: boolean): void;
 }
+export interface OptionAbort {
+    signal?: AbortSignal;
+}
+export type VProviderFileSystemReadFileOptions = OptionAbort;
+export type VProviderFileSystemReadDirectoryOptions = OptionAbort;
 export interface VProviderFileSystem extends Disposable {
-    readFile(url: UrlOrReference): Promise<FileResource>;
+    readFile(url: UrlOrReference, options?: VProviderFileSystemReadFileOptions): Promise<FileResource>;
     writeFile(file: FileResource): Promise<FileReference>;
     /**
      * Information about the provider.

package/dist/esm/common/CFileReference.d.ts

@@ -1,5 +1,5 @@
 import type { BufferEncoding } from '../models/BufferEncoding.js';
-import type { FileReference, UrlOrReference } from '../models/FileResource.js';
+import type { FileReference, FileResourceRequest, UrlOrReference } from '../models/FileResource.js';
 export declare class CFileReference implements FileReference {
     readonly url: URL;
     readonly encoding: BufferEncoding | undefined;
@@ -32,4 +32,5 @@ export declare class CFileReference implements FileReference {
 export declare function toFileReference(file: UrlOrReference, encoding?: BufferEncoding, baseFilename?: string, gz?: boolean | undefined): FileReference;
 export declare function isFileReference(ref: UrlOrReference): ref is FileReference;
 export declare function renameFileReference(ref: FileReference, newUrl: URL): FileReference;
+export declare function toFileResourceRequest(file: UrlOrReference, encoding?: BufferEncoding, signal?: AbortSignal): FileResourceRequest;
 //# sourceMappingURL=CFileReference.d.ts.map

package/dist/esm/common/CFileReference.js

@@ -54,4 +54,10 @@ export function isFileReference(ref) {
 export function renameFileReference(ref, newUrl) {
     return new CFileReference(newUrl, ref.encoding, ref.baseFilename, ref.gz);
 }
+export function toFileResourceRequest(file, encoding, signal) {
+    const fileReference = typeof file === 'string' ? toFileURL(file) : file;
+    if (fileReference instanceof URL)
+        return { url: fileReference, encoding, signal };
+    return { url: fileReference.url, encoding: encoding ?? fileReference.encoding, signal };
+}
 //# sourceMappingURL=CFileReference.js.map

package/dist/esm/common/CFileResource.d.ts

@@ -10,6 +10,7 @@ export declare class CFileResource implements TextFileResource {
     constructor(url: URL, content: string | ArrayBufferView, encoding: BufferEncoding | undefined, baseFilename: string | undefined, gz: boolean | undefined);
     get gz(): boolean;
     getText(encoding?: BufferEncoding): string;
+    getBytes(): Uint8Array;
     toJson(): {
         url: string;
         content: string;

package/dist/esm/common/CFileResource.js

@@ -1,5 +1,5 @@
 import { assert } from '../errors/assert.js';
-import { decode, isGZipped } from './encode-decode.js';
+import { decode, encodeString, isGZipped } from './encode-decode.js';
 export class CFileResource {
     url;
     content;
@@ -30,6 +30,12 @@ export class CFileResource {
         this._text = text;
         return text;
     }
+    getBytes() {
+        const arrayBufferview = typeof this.content === 'string' ? encodeString(this.content, this.encoding) : this.content;
+        return arrayBufferview instanceof Uint8Array
+            ? arrayBufferview
+            : new Uint8Array(arrayBufferview.buffer, arrayBufferview.byteOffset, arrayBufferview.byteLength);
+    }
     toJson() {
         return {
             url: this.url.href,

package/dist/esm/common/encode-decode.js

@@ -6,7 +6,7 @@ const BOM_LE = 0xfffe;
 const decoderUTF8 = new TextDecoder('utf8');
 const decoderUTF16LE = new TextDecoder('utf-16le');
 const decoderUTF16BE = createTextDecoderUtf16BE();
-// const encoderUTF8 = new TextEncoder();
+const encoderUTF8 = new TextEncoder();
 // const encoderUTF16LE = new TextEncoder('utf-16le');
 export function decodeUtf16LE(data) {
     const buf = asUint8Array(data);
@@ -60,6 +60,11 @@ export function decode(data, encoding) {
 }
 export function encodeString(str, encoding, bom) {
     switch (encoding) {
+        case undefined:
+        case 'utf-8':
+        case 'utf8': {
+            return encoderUTF8.encode(str);
+        }
         case 'utf-16be':
         case 'utf16be': {
             return encodeUtf16BE(str, bom);

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

@@ -53,10 +53,10 @@ const supportedFetchProtocols = { 'http:': true, 'https:': true };
  * Handle fetching a file from http
  */
 const handleRequestFsReadFileHttp = RequestFsReadFile.createRequestHandler((req, next) => {
-    const { url } = req.params;
+    const { url, signal, encoding } = req.params;
     if (!(url.protocol in supportedFetchProtocols))
         return next(req);
-    return createResponse(fetchURL(url).then((content) => CFileResource.from({ ...req.params, content })));
+    return createResponse(fetchURL(url, signal).then((content) => CFileResource.from({ url, encoding, content })));
 }, undefined, 'Node: Read Http(s) file.');
 /**
  * Handle decoding a data url

package/dist/esm/models/FileResource.d.ts

@@ -20,6 +20,20 @@ export interface FileReference {
      */
     readonly gz?: boolean | undefined;
 }
+export interface FileResourceRequest {
+    /**
+     * The URL of the File
+     */
+    readonly url: URL;
+    /**
+     * The encoding to use when reading the file.
+     */
+    readonly encoding?: BufferEncoding | undefined;
+    /**
+     * The signal to use to abort the request.
+     */
+    readonly signal?: AbortSignal | undefined;
+}
 export interface FileResource extends FileReference {
     /**
      * The contents of the file
@@ -34,6 +48,10 @@ export interface TextFileResource extends FileResource {
      *   If the content is a string, then the encoding is ignored.
      */
     getText(encoding?: BufferEncoding): string;
+    /**
+     * Get the bytes of the file.
+     */
+    getBytes(): Uint8Array;
 }
 export type UrlOrFilename = string | URL;
 export type UrlOrReference = UrlOrFilename | FileReference;

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

@@ -1,3 +1,3 @@
 export declare function fetchHead(request: string | URL): Promise<Headers>;
-export declare function fetchURL(url: URL): Promise<Buffer>;
+export declare function fetchURL(url: URL, signal?: AbortSignal): Promise<Buffer>;
 //# sourceMappingURL=fetch.d.ts.map

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

@@ -14,9 +14,11 @@ export async function fetchHead(request) {
         throw toFetchUrlError(e, url);
     }
 }
-export async function fetchURL(url) {
+export async function fetchURL(url, signal) {
     try {
-        const response = await fetch(url);
+        // eslint-disable-next-line n/no-unsupported-features/node-builtins
+        const request = signal ? new Request(url, { signal }) : url;
+        const response = await fetch(request);
         if (!response.ok) {
             throw FetchUrlError.create(url, response.status);
         }

package/dist/esm/requests/RequestFsReadFile.d.ts

@@ -1,11 +1,5 @@
 import type { ServiceRequestFactoryRequestType } from '@cspell/cspell-service-bus';
-import type { BufferEncoding } from '../models/BufferEncoding.js';
-import type { TextFileResource } from '../models/FileResource.js';
-interface RequestParams {
-    readonly url: URL;
-    readonly encoding?: BufferEncoding | undefined;
-}
-export declare const RequestFsReadFile: import("@cspell/cspell-service-bus").ServiceRequestFactory<import("@cspell/cspell-service-bus").ServiceRequest<"fs:readFile", RequestParams, Promise<TextFileResource>>, RequestParams, "fs:readFile">;
+import type { FileResourceRequest, TextFileResource } from '../models/FileResource.js';
+export declare const RequestFsReadFile: import("@cspell/cspell-service-bus").ServiceRequestFactory<import("@cspell/cspell-service-bus").ServiceRequest<"fs:readFile", FileResourceRequest, Promise<TextFileResource>>, FileResourceRequest, "fs:readFile">;
 export type RequestFsReadFile = ServiceRequestFactoryRequestType<typeof RequestFsReadFile>;
-export {};
 //# sourceMappingURL=RequestFsReadFile.d.ts.map

package/dist/esm/requests/RequestZlibInflate.d.ts

@@ -2,7 +2,7 @@ import type { ServiceRequestFactoryRequestType } from '@cspell/cspell-service-bu
 interface RequestParams {
     readonly data: ArrayBufferView;
 }
-export declare const RequestZlibInflate: import("@cspell/cspell-service-bus").ServiceRequestFactory<import("@cspell/cspell-service-bus").ServiceRequest<"zlib:inflate", RequestParams, ArrayBufferView>, RequestParams, "zlib:inflate">;
+export declare const RequestZlibInflate: import("@cspell/cspell-service-bus").ServiceRequestFactory<import("@cspell/cspell-service-bus").ServiceRequest<"zlib:inflate", RequestParams, ArrayBufferView<ArrayBufferLike>>, RequestParams, "zlib:inflate">;
 export type RequestZlibInflate = ServiceRequestFactoryRequestType<typeof RequestZlibInflate>;
 export {};
 //# sourceMappingURL=RequestZlibInflate.d.ts.map

package/package.json

@@ -4,7 +4,7 @@
     "access": "public",
     "provenance": true
   },
-  "version": "8.16.0",
+  "version": "8.17.0",
   "description": "A library of useful I/O functions used across various cspell tools.",
   "type": "module",
   "sideEffects": false,
@@ -53,11 +53,12 @@
   },
   "devDependencies": {
     "lorem-ipsum": "^2.0.8",
-    "typescript": "~5.6.3"
+    "typescript": "~5.7.2",
+    "vitest-fetch-mock": "^0.4.2"
   },
   "dependencies": {
-    "@cspell/cspell-service-bus": "8.16.0",
-    "@cspell/url": "8.16.0"
+    "@cspell/cspell-service-bus": "8.17.0",
+    "@cspell/url": "8.17.0"
   },
-  "gitHead": "41cd50f9ba34033b6da32408855d7fc3b888c5e0"
+  "gitHead": "cac17fe7b993db5965aa441648b1c22cb5486929"
 }