smartfile/readme.md

# SmartFile
> SmartFile offers smart ways to work with files in nodejs.

## Install
To install SmartFile, use npm or Yarn as follows:

```
npm install @push.rocks/smartfile --save
```
Or:
```
yarn add @push.rocks/smartfile
```

## Usage

SmartFile is a comprehensive toolkit for file manipulation in Node.js. It provides functionalities for working with the filesystem, in-memory operations, streaming, and handling virtual directories. Below, you will find examples showcasing how to utilize these functionalities effectively.

### Basic File Operations

For reading and writing files, SmartFile provides synchronous and asynchronous methods. Here’s how you can use them:

#### Async Write to File

```typescript
import { memory } from '@push.rocks/smartfile';

const myData: string = 'Hello, SmartFile!';

// Writing string data to a file asynchronously
memory.toFs(myData, './data/hello.txt');
```

#### Sync Write to File

```typescript
import { memory } from '@push.rocks/smartfile';

const myData: string = 'Hello, World!';

// Writing string data to a file synchronously
memory.toFsSync(myData, './data/helloSync.txt');
```

### Working with Streams

Streaming files to and from the filesystem is made easy with SmartFile. Here’s an example:

#### Creating Read and Write Streams

```typescript
import { fsStream } from '@push.rocks/smartfile';
import * as fs from 'fs';

// Creating a read stream
const readStream = fsStream.createReadStream('./data/readme.txt');

// Creating a write stream
const writeStream = fsStream.createWriteStream('./data/copy.txt');

// Piping the read stream to the write stream
readStream.pipe(writeStream);
```

### Dealing with Virtual Directories

Virtual directories allow you to group and manipulate files as if they were in a filesystem structure without actually writing them to disk.

```typescript
import { VirtualDirectory } from '@push.rocks/smartfile';

(async () => {
  // Creating a virtual directory from the file system
  const virtualDir = await VirtualDirectory.fromFsDirPath('./myDirectory');

  // Adding files from another virtual directory
  const anotherVirtualDir = await VirtualDirectory.fromFsDirPath('./anotherDirectory');
  await virtualDir.addVirtualDirectory(anotherVirtualDir, 'merged');

  // Saving the virtual directory to disk
  await virtualDir.saveToDisk('./outputDirectory');
})();
```

### Advanced File Manipulation

SmartFile also allows for more advanced file manipulation techniques through the `SmartFile` class.

```typescript
import { SmartFile } from '@push.rocks/smartfile';

(async () => {
  // Create a SmartFile instance from a file path
  const smartFile = await SmartFile.fromFilePath('./data/example.txt');

  // Edit the file content
  await smartFile.editContentAsString(async (currentContent: string) => {
    return currentContent.toUpperCase();
  });

  // Write the changes back to disk
  await smartFile.write();
})();
```

### Conversion and Interpretation

You can easily convert file contents to objects or interpret file types for further processing:

```typescript
import { memory } from '@push.rocks/smartfile';

(async () => {
  const fileString: string = await fs.promises.readFile('./data/example.json', 'utf8');
  const fileObject = memory.toObject(fileString, 'json');

  console.log(fileObject);
  // Proceed with the object...
})();
```

SmartFile simplifies handling files in a Node.js environment, providing a concise, promise-based API for various file operations, stream handling, and in-memory file manipulation. Whether you're dealing with physical files on the disk, manipulating file streams, or managing virtual files and directories, SmartFile has got you covered.

## Information on Licensing

SmartFile is licensed under the MIT License. This permissive license is short and to the point. It lets people do anything they want with your code as long as they provide attribution back to you and don’t hold you liable.