4.0.14

.gitea/workflows/default_nottags.yaml

@@ -1,66 +0,0 @@
-name: Default (not tags)
-
-on:
-  push:
-    tags-ignore:
-      - '**'
-
-env:
-  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
-  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
-  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
-  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
-  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
-
-jobs:
-  security:
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Install pnpm and npmci
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-
-      - name: Run npm prepare
-        run: npmci npm prepare
-
-      - name: Audit production dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --prod
-        continue-on-error: true
-
-      - name: Audit development dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --dev
-        continue-on-error: true
-
-  test:
-    if: ${{ always() }}
-    needs: security
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Test stable
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm test
-
-      - name: Test build
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm build

.gitea/workflows/default_tags.yaml

@@ -1,124 +0,0 @@
-name: Default (tags)
-
-on:
-  push:
-    tags:
-      - '*'
-
-env:
-  IMAGE: code.foss.global/host.today/ht-docker-node:npmci
-  NPMCI_COMPUTED_REPOURL: https://${{gitea.repository_owner}}:${{secrets.GITEA_TOKEN}}@/${{gitea.repository}}.git
-  NPMCI_TOKEN_NPM: ${{secrets.NPMCI_TOKEN_NPM}}
-  NPMCI_TOKEN_NPM2: ${{secrets.NPMCI_TOKEN_NPM2}}
-  NPMCI_GIT_GITHUBTOKEN: ${{secrets.NPMCI_GIT_GITHUBTOKEN}}
-  NPMCI_URL_CLOUDLY: ${{secrets.NPMCI_URL_CLOUDLY}}
-
-jobs:
-  security:
-    runs-on: ubuntu-latest
-    continue-on-error: true
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Audit production dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --prod
-        continue-on-error: true
-
-      - name: Audit development dependencies
-        run: |
-          npmci command npm config set registry https://registry.npmjs.org
-          npmci command pnpm audit --audit-level=high --dev
-        continue-on-error: true
-
-  test:
-    if: ${{ always() }}
-    needs: security
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Test stable
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm test
-
-      - name: Test build
-        run: |
-          npmci node install stable
-          npmci npm install
-          npmci npm build
-
-  release:
-    needs: test
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Release
-        run: |
-          npmci node install stable
-          npmci npm publish
-
-  metadata:
-    needs: test
-    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    container:
-      image: ${{ env.IMAGE }}
-    continue-on-error: true
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Prepare
-        run: |
-          pnpm install -g pnpm
-          pnpm install -g @ship.zone/npmci
-          npmci npm prepare
-
-      - name: Code quality
-        run: |
-          npmci command npm install -g typescript
-          npmci npm install
-
-      - name: Trigger
-        run: npmci trigger
-
-      - name: Build docs and upload artifacts
-        run: |
-          npmci node install stable
-          npmci npm install
-          pnpm install -g @git.zone/tsdoc
-          npmci command tsdoc
-        continue-on-error: true

.gitignore

@@ -1,23 +1,12 @@
-.nogit/
-
-# artifacts
-coverage/
-public/
-
-# installs
 node_modules/
+.settings/
+.idea/
+coverage/
+docs/
 
-# caches
-.yarn/
-.cache/
-.rpt2_cache
+ts/*.js
+ts/*.js.map
+ts/typings/
 
-# builds
-dist/
-dist_*/
+test/temp/
 
-# AI
-.claude/
-.serena/
-
-#------# custom

.gitlab-ci.yml

@@ -0,0 +1,37 @@
+image: hosttoday/ht-docker-node:npmts
+
+stages:
+- test
+- release
+
+testLEGACY:
+  stage: test
+  script:
+    - npmci test legacy
+  tags:
+    - docker
+  allow_failure: true
+
+testLTS:
+  stage: test
+  script:
+    - npmci test lts
+  tags:
+    - docker
+    
+testSTABLE:
+  stage: test
+  script:
+    - npmci test stable
+  tags:
+    - docker
+
+release:
+  stage: release
+  environment: npm_registry
+  script:
+    - npmci publish
+  only:
+    - tags
+  tags:
+    - docker

.travis.yml

@@ -0,0 +1,15 @@
+language: node_js
+node_js:
+- 4
+- stable
+deploy:
+  provider: npm
+  email: npm@lossless.digital
+  api_key:
+    secure: wIOQHE7Jbck2j5lcv1Rc8T9/1wbHNGLxqJ6pttNZ+hG1+w77TYnjNYuGtM2xQCXitXSFDoogU8MpiYieOQHYypFgJ6Ns8MTeKIzNJSnlOWdCSN/lVptscT8pyC6qD4IBAyi8m5F2HoGQR+IzcdDBPjXLaPbH7jn8hc9rNY+LNktmYOXfOr37P40pxYrf16GLwrkjQIK8pbkdIbNA0D0k3apTGqw+HsneN2D/O/zAYaB3ojm40ttgPAGYF5PO5t6uqIbPFgIPkMWsO1HbV6I+vOAuIf0KYUqnR/YZd5yFcxFt3c+bfyc8/LP4vy5FyKMLXHe4IXIjXPYetOSiVHgMMYaxawU51OqwIKO+87FJ1TdaVmacMFO0wagl2QS0ceQBn8KBUhljHu/fDInK82uy15Iddk44EhnTx1MIxxgH5WMM6aQB2vuqnViPghs4nA0Y/Dz2U69267fhvmZvEWWUndz058EksHdZsIt5WCqQErI/dWLXMGom94CuZv6nkoVHCw8CO5dqVvfqUFL7Qyw59kRbiUPItFVoiV8ptLUX9tnQ5xBukNRkFX34ViM9YvBRlGt5e//f+cWjUpXFvbrwkqusXArplpxIaUSsQKh7XaMB5DcZ5jDDdjKzIMDf6QWsMTU1rjfQS5ZS3eV5LPy0UlfpDGK28oK2/o8fM+yydVk=
+  on:
+    tags: true
+    repo: pushrocks/smartfile
+notifications:
+  slack:
+    secure: f5Uss0z9RPl/QcA/DroB8loyE93aOYI6bqCkrsiUscmZtlv/TVQtT4dxqGA6uvcG6iTQDBi3Ul88dQxWkRm4IqbhY35/iMaV2dHW4FVYMAh8GQMbsfL2sALCcufxD9blw47awv3iFcwhV1EeyesscjgL0JIjduk96v/7G/6QIO2838M1lzlgtj+kRUkim8qkaEs1je3gRrhMUIjLuAdscMXyUKYFMjWo9ACSjVUl30R/ZNemb18itIja6i92GotreBgcfEMczvy58ovDC7xdJUsY8LjMI01DwY+WPRnI0tAhsuI8moBwwcdM4e3bAjKjucQRjO33O5bMWRZ6QCiYd0DnCEFyCPQLJ4GSy/tkD00n8ijLHAOSV3AH1zNbdK1EAdSPQXDvlI36KJn/2hyQLoitGHVUPr76ujJWP82ypO2tgIp3XQU0dJVCxDuHnwJO2+hjdI+gCPqxNTpjeujHx3UdkTGNRjuuf9dlZ/D08fApjYxy2fxItTqo3QjP/nrqvBXUOPP8yPHpjIT4H2t5Pr4SJjBGI6X4qhKyFj6s9rA/Xu1rL+45zu1C3uC3z+u3T9UwrbzJ/cZM6r6UQvQmUvIfBNaMlg4I/diQCDIPL+Rhop2nylY3IcHmJnk2itn7kOqj1tohCpFEml5pRuSZy4udWywkdtyBAsHWFLF7oiQ=

.vscode/launch.json

@@ -1,11 +0,0 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "command": "npm test",
-      "name": "Run npm test",
-      "request": "launch",
-      "type": "node-terminal"
-    }
-  ]
-}

.vscode/settings.json

@@ -1,26 +0,0 @@
-{
-  "json.schemas": [
-    {
-      "fileMatch": ["/npmextra.json"],
-      "schema": {
-        "type": "object",
-        "properties": {
-          "npmci": {
-            "type": "object",
-            "description": "settings for npmci"
-          },
-          "gitzone": {
-            "type": "object",
-            "description": "settings for gitzone",
-            "properties": {
-              "projectType": {
-                "type": "string",
-                "enum": ["website", "element", "service", "npm", "wcc"]
-              }
-            }
-          }
-        }
-      }
-    }
-  ]
-}

LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015 Lossless GmbH
+Copyright (c) 2015 Push.Rocks
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -0,0 +1,13 @@
+# smartfile
+make files easily accessible for processing in javascript.
+
+## Status
+[![build status](https://gitlab.com/pushrocks/smartfile/badges/master/build.svg)](https://gitlab.com/pushrocks/smartfile/commits/master)
+[![Dependency Status](https://david-dm.org/pushrocks/smartfile.svg)](https://david-dm.org/pushrocks/smartfile)
+[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smartfile/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smartfile/master/dependencies/npm)
+[![bitHound Code](https://www.bithound.io/github/pushrocks/smartfile/badges/code.svg)](https://www.bithound.io/github/pushrocks/smartfile)
+[![codecov.io](https://codecov.io/github/pushrocks/smartfile/coverage.svg?branch=master)](https://codecov.io/github/pushrocks/smartfile?branch=master)
+
+## Usage
+smartfile is an approach of being one tool to handle files in diverse environments.
+It can fetch files from remote locations, work with local disks and do pure memory operations.

appveyor.yml

@@ -0,0 +1,10 @@
+environment:
+  nodejs_version: "4"
+install:
+  - ps: Install-Product node $env:nodejs_version
+  - npm install
+test_script:
+  - node --version
+  - npm --version
+  - npm test
+build: off

changelog.md

@@ -1,496 +0,0 @@
-# Changelog
-
-## 2025-11-22 - 13.0.1 - fix(smartfile)
-Stream and filesystem integrations: remove fs-extra, switch to fs/promises.rename, add Web WritableStream compatibility, and use smartFs recursive directory methods; update plugins exports and README.
-
-- Remove fs-extra dependency and its types from package.json and stop exporting fsExtra from plugins.
-- Replace fs-extra rename with fs/promises.rename in SmartFile.rename to use native promises API.
-- Add Web WritableStream handling in StreamFile.writeToDisk (convert to Node.js Writable via Writable.fromWeb) and ensure Web ReadableStream conversion in createReadStream.
-- Use smartFs.directory(...).recursive().create() when creating directories and smartFs.directory(path).recursive().list() when listing to ensure recursive behavior.
-- Update README to add Issue Reporting and Security section pointing to community.foss.global for bug/vulnerability reports.
-
-## 2025-11-22 - 13.0.0 - BREAKING CHANGE(SmartFileFactory)
-Refactor to in-memory file API and introduce SmartFileFactory; delegate filesystem operations to @push.rocks/smartfs; bump to 12.0.0
-
-- Introduce SmartFileFactory as the canonical entry point for creating SmartFile, StreamFile and VirtualDirectory instances.
-- Refactor SmartFile, StreamFile and VirtualDirectory to be in-memory representations and accept an optional SmartFs instance for filesystem operations.
-- Delegate low-level filesystem operations to @push.rocks/smartfs (added as a peerDependency); legacy fs/memory/fsStream/interpreter namespace exports removed/deprecated.
-- Add StreamFile.toSmartFile(), VirtualDirectory.loadFromDisk(), and other convenience methods to work with the new factory/smartFs integration.
-- Update tests to use a MockSmartFs and the factory API; add test assets.
-- Documentation and readme updated with migration instructions and examples showing SmartFileFactory.nodeFs() and SmartFs usage.
-- Bumped package version to 12.0.0 — this is a breaking change; consumers should migrate from legacy namespace exports to the factory + @push.rocks/smartfs workflow.
-
-## 2025-08-18 - 11.2.7 - fix(ci)
-Remove .npmrc containing hard-coded npm registry configuration
-
-- Removed .npmrc which contained 'registry=https://registry.npmjs.org/'
-- Avoids committing environment-specific npm registry configuration; rely on user or CI environment settings instead
-
-## 2025-08-18 - 11.2.6 - fix(fs)
-Improve fs and stream handling, enhance SmartFile/StreamFile, update tests and CI configs
-
-- Fix listFileTree to correctly handle '**/' patterns by running both root and nested patterns and deduplicating results.
-- Enhance waitForFileToBeReady: support directory paths (wait for first file) and improved file-stability checks with timeouts and retries.
-- StreamFile improvements: support Web ReadableStream -> Node Readable conversion, better multi-use buffering, more robust fromUrl/fromBuffer/fromStream implementations, and accurate byte-length computation.
-- SmartFile updates: switch fromUrl to SmartRequest, robust rename (optional on-disk rename), safer read/write paths and consistent Buffer handling for hashing and content edits.
-- fs module tweaks: copy/copySync gained replaceTargetDir option, improved toObjectSync error messages, toReadStream now validates existence, and various synchronous/async API consistency fixes.
-- memory module: consistent async/sync write APIs and smartfileArrayToFs formatting/behavior fixes.
-- fsstream: improved stream processing and SmartReadStream robustness (error handling, read logic and watcher improvements).
-- Tests: reformatted and strengthened tests (more explicit assertions, added tests for '**/*.ts' and '**/*' edge cases, updated imports to tapbundle usage).
-- CI/workflows: updated IMAGE and NPMCI_COMPUTED_REPOURL values and switched npmci package install to @ship.zone/npmci in workflow files.
-- package.json: bumped various dependencies, updated test script (timeout, logfile), added typings/main fields, homepage fix, pnpm overrides and minor metadata fixes.
-- .gitignore: added entries for AI tool folders (.claude/, .serena/).
-- Docs/readme: expanded README with clearer examples, features and TypeScript usage; updated readme hints for listFileTree behavior.
-
-## 2025-05-26 - 11.2.5 - fix(dev)
-
-Update dev dependencies and add local permission settings
-
-- Bump @git.zone/tsbuild from 2.5.2 to 2.6.4
-- Bump @git.zone/tstest from 1.9.0 to 2.2.5
-- Add .claude/settings.local.json to configure permissions for Bash(pnpm test:\*)
-
-## 2025-05-24 - 11.2.4 - fix(config)
-
-Add local permissions configuration for pnpm test commands in .claude/settings.local.json
-
-- Introduced .claude/settings.local.json to allow Bash(pnpm test:\*) permissions
-- Ensured local testing commands have proper execution rights
-
-## 2025-05-21 - 11.2.2 - fix(tests/settings)
-
-Improve test assertions and update local settings permissions
-
-- Refactor StreamFile tests to assert content string type using toBeTypeofString
-- Update file existence tests to use resolves.toBeTrue and resolves.toBeFalse for cleaner promise handling
-- Add .claude/settings.local.json to allow specific Bash permissions for pnpm test commands
-
-## 2025-05-21 - 11.2.1 - fix(fs)
-
-Fix inconsistent glob matching in listFileTree and update test imports and dependency versions for enhanced stability.
-
-- Enhanced listFileTree to support \*\*/ patterns by using dual patterns (root and nested) with deduplication.
-- Updated test imports to use '@git.zone/tstest/tapbundle' for consistency across test files.
-- Bumped dependency versions (@push.rocks/lik, smartpromise, smartrequest, glob) in package.json.
-- Added npm configuration (.npmrc) and local settings for improved test verbosity.
-
-## 2025-01-29 - 11.2.0 - feat(fs)
-
-Enhanced copy method with optional replaceTargetDir option for directory replacement
-
-- Added optional 'replaceTargetDir' option to 'copy' and 'copySync' methods in 'fs.ts'.
-- The 'replaceTargetDir' option allows replacing the target directory if both source and target are directories.
-
-## 2025-01-29 - 11.1.9 - fix(fs)
-
-Fix directory handling in copy and copySync functions
-
-- Ensured existing directories at destination are removed before copying over them in async copy.
-- Added a similar check and handling for synchronous copySync when destination is a directory.
-
-## 2025-01-29 - 11.1.8 - fix(fs)
-
-Fixed copy and copySync functions to ensure they always overwrite files.
-
-- Fixed bug in copy function where files were not being overwritten when they already existed at the destination.
-- Fixed bug in copySync function to ensure files are overwritten to match the async function's behavior.
-
-## 2025-01-29 - 11.1.7 - fix(fs)
-
-Refactor copy and copySync functions to simplify return type
-
-- Changed the return type of fs.copy and fs.copySync from boolean to void.
-- Removed unnecessary promise handling in fs.copy.
-
-## 2025-01-29 - 11.1.6 - fix(fs)
-
-Fix issues with fs file copy functions.
-
-- Updated dependencies in package.json.
-- Corrected comments for asynchronous and synchronous file copy functions in fs.ts.
-
-## 2025-01-07 - 11.1.5 - fix(fs)
-
-Improve waitForFileToBeReady function to handle directories and file stabilization
-
-- Enhanced the waitForFileToBeReady to handle directory paths by checking for file existence within directories and waiting for stabilization.
-- Modified the watcher logic to cater to changes when monitoring directories for file appearance.
-- Introduced a helper function to ensure paths exist and another to resolve the first file in directories.
-- Corrected logic for polling and stabilizing files within directories.
-
-## 2025-01-07 - 11.1.4 - fix(fs)
-
-Fix file existence check in waitForFileToBeReady method.
-
-- Ensured that the directory and file exist before setting up the watcher in waitForFileToBeReady.
-- Changed ensureDirectoryExists to ensureFileExists for correct file path verification.
-- Handled ENOENT errors correctly to retry file existence checks until timeout is reached.
-
-## 2025-01-07 - 11.1.3 - fix(fs)
-
-Fix TypeScript type issue in fs module
-
-- Corrected a TypeScript type in the fs module's checkFileStability function.
-
-## 2025-01-07 - 11.1.2 - fix(fs)
-
-Fix issues in file stability check and directory existence verification in fs module
-
-- Removed unused variable 'isFileAvailable' in 'waitForFileToBeReady'.
-- Fixed logic for ensuring the target directory exists before setting up file stability watcher.
-- Refactored directory existence logic into 'ensureDirectoryExists' function.
-
-## 2025-01-07 - 11.1.1 - fix(fs)
-
-Improve waitForFileToBeReady function for file stability detection
-
-- Enhanced error handling and file stability checks in waitForFileToBeReady function
-- Added timeout feature for file readiness check
-- Improved directory access check before file availability check
-
-## 2025-01-07 - 11.1.0 - feat(SmartFile)
-
-Add rename functionality to SmartFile class
-
-- Implemented a new method to rename a file within the SmartFile class.
-- The rename method updates the file path and optionally writes the renamed file to the disk.
-
-## 2024-12-15 - 11.0.23 - fix(fs)
-
-Handle errors in toObjectSync method
-
-- Added error handling in toObjectSync function to capture and provide more informative error messages.
-
-## 2024-06-23 - 11.0.22 - fix(core)
-
-Update dependencies and changelog
-
-- Updated @push.rocks/smartstream to ^3.0.44
-- Updated glob to ^10.4.2
-- Updated @types/node to ^20.14.8
-
-## 2024-06-23 - 11.0.21 - fix(dependencies)
-
-Update dependencies to latest versions
-
-- Updated @push.rocks/smartpromise to ^4.0.4
-- Updated @push.rocks/smartstream to ^3.0.44
-- Updated glob to ^10.4.2
-- Updated @types/node to ^20.14.8
-
-## 2024-06-07 - 11.0.20 - Changelog
-
-11.0.20
-
-## 2024-06-07 - 11.0.19 - fix(core): update
-
-11.0.19
-
-- fix(core): update
-
-## 2024-06-07 - 11.0.18 - fix(core): update
-
-11.0.18
-
-- fix(core): update
-
-## 2024-06-06 - 11.0.17 - fix(core): update
-
-11.0.17
-
-- fix(core): update
-
-## 2024-06-06 - 11.0.16 - fix(core): update
-
-11.0.16
-
-- fix(core): update
-
-## 2024-05-29 - 11.0.16 - update description
-
-11.0.16
-
-- update description
-
-## 2024-05-17 - 11.0.15 - fix(core): update
-
-11.0.15
-
-- fix(core): update
-
-## 2024-04-14 - 11.0.14 - update tsconfig
-
-11.0.14
-
-- update tsconfig
-
-## 2024-04-12 - 11.0.13 - fix(core): update
-
-11.0.13
-
-- fix(core): update
-
-## 2024-04-12 - 11.0.12 - fix(core): update
-
-11.0.12
-
-- fix(core): update
-
-## 2024-04-12 - 11.0.11 - fix(core): update
-
-11.0.11
-
-- fix(core): update
-
-## 2024-04-03 - 11.0.10 - fix(core): update
-
-11.0.10
-
-- fix(core): update
-
-## 2024-04-03 - 11.0.9 - fix(core): update
-
-11.0.9
-
-- fix(core): update
-
-## 2024-04-02 - 11.0.8 - fix(core): update
-
-11.0.8
-
-- fix(core): update
-
-## 2024-04-02 - 11.0.7 - fix(core): update
-
-11.0.7
-
-- fix(core): update
-
-## 2024-04-02 - 11.0.6 - fix(core): update
-
-11.0.6
-
-- fix(core): update
-
-## 2024-04-01 - 11.0.5 - update npmextra.json
-
-11.0.5
-
-- update npmextra.json: githost
-
-## 2024-04-01 - 11.0.4 - fix(core): update
-
-11.0.4
-
-- fix(core): update
-
-## 2023-11-24 - 11.0.3 - fix(core): update
-
-11.0.3
-
-- fix(core): update
-
-## 2023-11-07 - 11.0.2 - fix(core): update
-
-11.0.2
-
-- fix(core): update
-
-## 2023-11-07 - 11.0.1 - fix(core): update
-
-11.0.1
-
-- fix(core): update
-
-## 2023-11-06 - 11.0.0 - fix(core): update
-
-11.0.0
-
-- fix(core): update
-
-## 2023-11-06 - 10.0.40 - BREAKING CHANGE(core): update
-
-10.0.40
-
-- BREAKING CHANGE(core): update
-
-## 2023-11-04 - 10.0.39 - fix(core): update
-
-10.0.39
-
-- fix(core): update
-
-## 2023-11-04 - 10.0.38 - fix(core): update
-
-10.0.38
-
-- fix(core): update
-
-## 2023-11-04 - 10.0.37 - fix(core): update
-
-10.0.37
-
-- fix(core): update
-
-## 2023-11-03 - 10.0.36 - fix(core): update
-
-10.0.36
-
-- fix(core): update
-
-## 2023-11-03 - 10.0.35 - fix(core): update
-
-10.0.35
-
-- fix(core): update
-
-## 2023-11-03 - 10.0.34 - fix(core): update
-
-10.0.34
-
-- fix(core): update
-
-## 2023-11-03 - 10.0.33 - fix(core): update
-
-10.0.33
-
-- fix(core): update
-
-## 2023-10-12 - 10.0.32 - fix(core): update
-
-10.0.32
-
-- fix(core): update
-
-## 2023-09-22 - 10.0.31 - fix(core): update
-
-10.0.31
-
-- fix(core): update
-
-## 2023-08-31 - 10.0.30 - fix(core): update
-
-10.0.30
-
-- fix(core): update
-
-## 2023-08-23 - 10.0.29 - fix(core): update
-
-10.0.29
-
-- fix(core): update
-
-## 2023-07-12 - 10.0.28 - fix(core): update
-
-10.0.28
-
-- fix(core): update
-
-## 2023-07-10 - 10.0.27 - fix(core): update
-
-10.0.27
-
-- fix(core): update
-
-## 2023-07-10 - 10.0.26 - fix(core): update
-
-10.0.26
-
-- fix(core): update
-
-## 2023-07-08 - 10.0.25 - fix(core): update
-
-10.0.25
-
-- fix(core): update
-
-## 2023-06-25 - 10.0.24 to 10.0.14 - Series of Fixes
-
-10.0.24 to 10.0.14
-
-- Series of fixes in the core module
-
-## 2023-01-09 - 10.0.13 to 10.0.6 - Series of Fixes
-
-10.0.13 to 10.0.6
-
-- Series of fixes in the core module
-
-## 2022-09-05 - 10.0.5 to 10.0.3 - Series of Fixes
-
-10.0.5 to 10.0.3
-
-- Series of fixes in the core module
-
-## 2022-06-07 - 10.0.2 to 10.0.1 - Series of Fixes
-
-10.0.2 to 10.0.1
-
-- Series of fixes in the core module
-
-## 2022-06-07 - 9.0.7 - BREAKING CHANGE(core): switch to esm
-
-9.0.7
-
-- BREAKING CHANGE(core): switch to esm
-
-## 2022-03-11 - 9.0.6 to 9.0.2 - Series of Fixes
-
-9.0.6 to 9.0.2
-
-- Series of fixes in the core module
-
-## 2021-12-01 - 9.0.1 - fix(core): update
-
-9.0.1
-
-- fix(core): update
-
-## 2021-12-01 - 9.0.0 - fix(absolute pathing)
-
-9.0.0
-
-- add functions for easily getting absolute paths
-
-## 2021-11-30 - 8.0.11 - BREAKING CHANGE(relative pathing)
-
-8.0.11
-
-- improved relative pathing
-
-## 2020-08-10 - 8.0.10 to 7.0.12 - Series of Fixes and Updates
-
-8.0.10 to 7.0.12
-
-- Series of fixes in the core module
-- BREAKING CHANGE(Smartfile class): switch to a Buffer-only approach
-
-## 2019-02-17 - 7.0.0 - fix(core): update dependencies
-
-7.0.0
-
-- fix(core): update dependencies
-
-## 2019-01-27 - 6.0.12 - BREAKING CHANGE(smartfile.fs.fileExists)
-
-6.0.12
-
-- now returns a Promise<boolean>
-
-## 2018-08-19 - 6.0.11 to 6.0.6 - Series of Fixes
-
-6.0.11 to 6.0.6
-
-- Series of fixes in core and dependencies
-
-## 2018-07-03 - 6.0.5 to 5.0.0 - Series of Fixes
-
-6.0.5 to 5.0.0
-
-- Series of fixes in core and dependencies
-
-## 2018-02-16 - 4.2.28 - BREAKING CHANGE(scope)
-
-4.2.28
-
-- switch to pushrocks scope

dist/index.d.ts

@@ -0,0 +1,11 @@
+import "typings-global";
+import * as SmartfileFs from "./smartfile.fs";
+import * as SmartfileInterpreter from "./smartfile.interpreter";
+import * as SmartfileMemory from "./smartfile.memory";
+import * as SmartfileRemote from "./smartfile.remote";
+export { Smartfile } from "./smartfile.classes.smartfile";
+export declare let fs: typeof SmartfileFs;
+export declare let interpreter: typeof SmartfileInterpreter;
+export declare let memory: typeof SmartfileMemory;
+export declare let remote: typeof SmartfileRemote;
+export declare let requireReload: (path: string) => any;

dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+require("typings-global");
+const SmartfileFs = require("./smartfile.fs");
+const SmartfileInterpreter = require("./smartfile.interpreter");
+const SmartfileMemory = require("./smartfile.memory");
+const SmartfileRemote = require("./smartfile.remote");
+var smartfile_classes_smartfile_1 = require("./smartfile.classes.smartfile");
+exports.Smartfile = smartfile_classes_smartfile_1.Smartfile;
+exports.fs = SmartfileFs;
+exports.interpreter = SmartfileInterpreter;
+exports.memory = SmartfileMemory;
+exports.remote = SmartfileRemote;
+exports.requireReload = SmartfileFs.requireReload;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsUUFBTyxnQkFBZ0IsQ0FBQyxDQUFBO0FBR3hCLE1BQVksV0FBVyxXQUFNLGdCQUFnQixDQUFDLENBQUE7QUFDOUMsTUFBWSxvQkFBb0IsV0FBTSx5QkFDdEMsQ0FBQyxDQUQ4RDtBQUMvRCxNQUFZLGVBQWUsV0FBTSxvQkFBb0IsQ0FBQyxDQUFBO0FBQ3RELE1BQVksZUFBZSxXQUFNLG9CQUFvQixDQUFDLENBQUE7QUFFdEQsNENBQXdCLCtCQUErQixDQUFDO0FBQWhELDREQUFnRDtBQUU3QyxVQUFFLEdBQUcsV0FBVyxDQUFDO0FBQ2pCLG1CQUFXLEdBQUcsb0JBQW9CLENBQUM7QUFDbkMsY0FBTSxHQUFHLGVBQWUsQ0FBQztBQUN6QixjQUFNLEdBQUcsZUFBZSxDQUFDO0FBQ3pCLHFCQUFhLEdBQUcsV0FBVyxDQUFDLGFBQWEsQ0FBQyJ9

dist/smartfile.classes.smartfile.d.ts

@@ -0,0 +1,3 @@
+export declare class Smartfile {
+    constructor();
+}

dist/smartfile.classes.smartfile.js

@@ -0,0 +1,8 @@
+"use strict";
+class Smartfile {
+    constructor() {
+    }
+    ;
+}
+exports.Smartfile = Smartfile;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRmaWxlLmNsYXNzZXMuc21hcnRmaWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRmaWxlLmNsYXNzZXMuc21hcnRmaWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTtJQUNJO0lBRUEsQ0FBQzs7QUFDTCxDQUFDO0FBSlksaUJBQVMsWUFJckIsQ0FBQSJ9

dist/smartfile.fs.d.ts

@@ -0,0 +1,111 @@
+/// <reference types="q" />
+import "typings-global";
+import plugins = require("./smartfile.plugins");
+/**
+ *
+ * @param filePath
+ * @returns {boolean}
+ */
+export declare let fileExistsSync: (filePath: any) => boolean;
+/**
+ *
+ * @param filePath
+ * @returns {any}
+ */
+export declare let fileExists: (filePath: any) => plugins.Q.Promise<{}>;
+/**
+ * Checks if given path points to an existing directory
+ */
+export declare let isDirectory: (pathArg: any) => boolean;
+/**
+ * Checks if a given path points to an existing file
+ */
+export declare let isFile: (pathArg: any) => boolean;
+/**
+ * ensures that a directory is in place
+ */
+export declare let ensureDir: (dirPathArg: string) => plugins.Q.Promise<{}>;
+/**
+ * ensures that a directory is in place
+ */
+export declare let ensureDirSync: (dirPathArg: string) => void;
+/**
+ * copies a file from A to B on the local disk
+ */
+export declare let copy: (fromArg: string, toArg: string) => plugins.Q.Promise<{}>;
+/**
+ * copies a file SYNCHRONOUSLY from A to B on the local disk
+ */
+export declare let copySync: (fromArg: string, toArg: string) => boolean;
+/**
+ * removes a file or folder from local disk
+ */
+export declare let remove: (pathArg: string) => plugins.Q.Promise<{}>;
+/**
+ * removes a file SYNCHRONOUSLY from local disk
+ */
+export declare let removeSync: (pathArg: string) => boolean;
+/**
+ *
+ * @param filePathArg
+ * @returns {*}
+ */
+export declare let toGulpStreamSync: (filePathArg: string) => any;
+export declare let toGulpDestSync: (folderPathArg: string) => any;
+/**
+ *
+ * @param filePathArg
+ * @param fileTypeArg
+ * @returns {any}
+ */
+export declare let toObjectSync: (filePathArg: any, fileTypeArg?: any) => any;
+/**
+ * reads a file content to a String
+ * @param filePath
+ * @returns {string|Buffer|any}
+ */
+export declare let toStringSync: (filePath: any) => any;
+/**
+ *
+ * @param filePathArg
+ * @param options
+ * @returns {number}
+ */
+export declare let toVinylSync: (filePathArg: any, options?: {}) => any;
+/**
+ * lets you reload files hot.
+ * @param path
+ * @returns {any}
+ */
+export declare let requireReload: (path: string) => any;
+/**
+ * lists Folders in a directory on local disk
+ * @returns Promise
+ */
+export declare let listFolders: (pathArg: string, regexFilter?: RegExp) => plugins.Q.Promise<{}>;
+/**
+ * lists Folders SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export declare let listFoldersSync: (pathArg: string, regexFilter?: RegExp) => string[];
+/**
+ * lists Files in a directory on local disk
+ * @returns Promise
+ */
+export declare let listFiles: (pathArg: string, regexFilter?: RegExp) => plugins.Q.Promise<{}>;
+/**
+ * lists Files SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export declare let listFilesSync: (pathArg: string, regexFilter?: RegExp) => string[];
+/**
+ * lists all items (folders AND files) in a directory on local disk
+ * @returns Promise
+ */
+export declare let listAllItems: (pathArg: string, regexFilter?: RegExp) => plugins.Q.Promise<{}>;
+/**
+ * lists all items (folders AND files) SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export declare let listAllItemsSync: (pathArg: string, regexFilter?: RegExp) => string[];
+export declare let listFileTree: (dirPath: string, miniMatchFilter: string) => plugins.Q.Promise<{}>;

dist/smartfile.interpreter.d.ts

@@ -0,0 +1,3 @@
+import "typings-global";
+export declare let filetype: (pathArg: string) => string;
+export declare let objectFile: (fileStringArg: string, fileTypeArg: any) => any;

dist/smartfile.interpreter.js

@@ -0,0 +1,21 @@
+"use strict";
+require("typings-global");
+const plugins = require("./smartfile.plugins");
+exports.filetype = (pathArg) => {
+    let extName = plugins.path.extname(pathArg);
+    let fileType = extName.replace(/\.([a-z]*)/, "$1"); //remove . form fileType
+    return fileType;
+};
+exports.objectFile = (fileStringArg, fileTypeArg) => {
+    switch (fileTypeArg) {
+        case "yml":
+        case "yaml":
+            return plugins.yaml.safeLoad(fileStringArg);
+        case "json":
+            return JSON.parse(fileStringArg);
+        default:
+            plugins.beautylog.error("file type " + fileTypeArg.blue + " not supported");
+            break;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRmaWxlLmludGVycHJldGVyLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnRmaWxlLmludGVycHJldGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSxRQUFPLGdCQUFnQixDQUFDLENBQUE7QUFFeEIsTUFBTyxPQUFPLFdBQVcscUJBQXFCLENBQUMsQ0FBQztBQUVyQyxnQkFBUSxHQUFHLENBQUMsT0FBYztJQUNqQyxJQUFJLE9BQU8sR0FBRyxPQUFPLENBQUMsSUFBSSxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUM1QyxJQUFJLFFBQVEsR0FBRyxPQUFPLENBQUMsT0FBTyxDQUFDLFlBQVksRUFBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLHdCQUF3QjtJQUMzRSxNQUFNLENBQUMsUUFBUSxDQUFDO0FBQ3BCLENBQUMsQ0FBQztBQUVTLGtCQUFVLEdBQUcsQ0FBQyxhQUFvQixFQUFFLFdBQVc7SUFDdEQsTUFBTSxDQUFDLENBQUMsV0FBVyxDQUFDLENBQUMsQ0FBQztRQUNsQixLQUFLLEtBQUssQ0FBRTtRQUNaLEtBQUssTUFBTTtZQUNQLE1BQU0sQ0FBQyxPQUFPLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUNoRCxLQUFLLE1BQU07WUFDUCxNQUFNLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxhQUFhLENBQUMsQ0FBQztRQUNyQztZQUNJLE9BQU8sQ0FBQyxTQUFTLENBQUMsS0FBSyxDQUFDLFlBQVksR0FBRyxXQUFXLENBQUMsSUFBSSxHQUFHLGdCQUFnQixDQUFDLENBQUM7WUFDNUUsS0FBSyxDQUFDO0lBQ2QsQ0FBQztBQUNMLENBQUMsQ0FBQSJ9

dist/smartfile.memory.d.ts

@@ -0,0 +1,51 @@
+/// <reference types="vinyl" />
+/// <reference types="q" />
+import "typings-global";
+import plugins = require("./smartfile.plugins");
+/**
+ * allows you to create a gulp stream
+ * from String, from an Array of Strings, from Vinyl File, from an Array of VinylFiles
+ * @param fileArg
+ * @returns stream.Readable
+ * @TODO: make it async;
+ */
+export declare let toGulpStream: (fileArg: string | string[] | plugins.vinyl | plugins.vinyl[], baseArg?: string) => any;
+/**
+ * converts file to Object
+ * @param fileStringArg
+ * @param fileTypeArg
+ * @returns {any|any}
+ */
+export declare let toObject: (fileStringArg: string, fileTypeArg: string) => any;
+/**
+ * takes a string and converts it to vinyl file
+ * @param fileArg
+ * @param optionsArg
+ */
+export declare let toVinylFileSync: (fileArg: string, optionsArg?: {
+    filename?: string;
+    base?: string;
+    relPath?: string;
+}) => plugins.vinyl;
+/**
+ * takes a string array and some options and returns a vinylfile array
+ * @param arrayArg
+ * @param optionsArg
+ */
+export declare let toVinylArraySync: (arrayArg: string[], optionsArg?: {
+    filename?: string;
+    base?: string;
+    relPath?: string;
+}) => any[];
+/**
+ * takes a vinylFile object and converts it to String
+ */
+export declare let toStringSync: (fileArg: plugins.vinyl) => string;
+/**
+ * writes string or vinyl file to disk.
+ * @param fileArg
+ * @param fileNameArg
+ * @param fileBaseArg
+ */
+export declare let toFs: (fileContentArg: string | plugins.vinyl, filePathArg: any) => plugins.Q.Promise<{}>;
+export declare let toFsSync: (fileArg: any, filePathArg: string) => void;

dist/smartfile.plugins.d.ts

@@ -0,0 +1,16 @@
+import "typings-global";
+export import beautylog = require("beautylog");
+export import fs = require("fs");
+export import fsExtra = require("fs-extra");
+export declare let gulp: any;
+export import glob = require("glob");
+export declare let g: {
+    remoteSrc: any;
+};
+export import path = require("path");
+export import Q = require("q");
+export import vinyl = require("vinyl");
+export declare let vinylFile: any;
+export declare let yaml: any;
+export declare let request: any;
+export declare let requireReload: any;

dist/smartfile.plugins.js

@@ -0,0 +1,18 @@
+"use strict";
+require("typings-global");
+exports.beautylog = require("beautylog");
+exports.fs = require("fs");
+exports.fsExtra = require("fs-extra");
+exports.gulp = require("gulp");
+exports.glob = require("glob");
+exports.g = {
+    remoteSrc: require("gulp-remote-src")
+};
+exports.path = require("path");
+exports.Q = require("q");
+exports.vinyl = require("vinyl");
+exports.vinylFile = require("vinyl-file");
+exports.yaml = require("js-yaml");
+exports.request = require("request");
+exports.requireReload = require("require-reload");
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnRmaWxlLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydGZpbGUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiO0FBQUEsUUFBTyxnQkFBZ0IsQ0FBQyxDQUFBO0FBQ1YsaUJBQVMsV0FBVyxXQUFXLENBQUMsQ0FBQztBQUNqQyxVQUFFLFdBQVcsSUFBSSxDQUFDLENBQUM7QUFDbkIsZUFBTyxXQUFXLFVBQVUsQ0FBQyxDQUFDO0FBQ2pDLFlBQUksR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLENBQUM7QUFDcEIsWUFBSSxXQUFXLE1BQU0sQ0FBQyxDQUFDO0FBQzFCLFNBQUMsR0FBRztJQUNYLFNBQVMsRUFBRSxPQUFPLENBQUMsaUJBQWlCLENBQUM7Q0FDeEMsQ0FBQztBQUNZLFlBQUksV0FBVyxNQUFNLENBQUMsQ0FBQztBQUN2QixTQUFDLFdBQVcsR0FBRyxDQUFDLENBQUM7QUFDakIsYUFBSyxXQUFXLE9BQU8sQ0FBQyxDQUFDO0FBQzVCLGlCQUFTLEdBQUcsT0FBTyxDQUFDLFlBQVksQ0FBQyxDQUFDO0FBQ2xDLFlBQUksR0FBRyxPQUFPLENBQUMsU0FBUyxDQUFDLENBQUM7QUFDMUIsZUFBTyxHQUFHLE9BQU8sQ0FBQyxTQUFTLENBQUMsQ0FBQztBQUM3QixxQkFBYSxHQUFHLE9BQU8sQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDIn0=

dist/smartfile.remote.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="q" />
+import "typings-global";
+import plugins = require("./smartfile.plugins");
+export declare let toFs: (from: string, toPath: string) => plugins.Q.Promise<{}>;
+/**
+ *
+ * @param filePathArg
+ * @returns {*}
+ */
+export declare let toGulpStreamSync: (filePathArg: string, baseArg: string) => any;
+/**
+ *
+ * @param fromArg
+ * @returns {any}
+ */
+export declare let toObject: (fromArg: string) => plugins.Q.Promise<{}>;
+/**
+ *
+ * @param fromArg
+ * @returns {any}
+ */
+export declare let toString: (fromArg: string) => plugins.Q.Promise<{}>;

dist/smartfile.remote.js

@@ -0,0 +1,66 @@
+"use strict";
+require("typings-global");
+const plugins = require("./smartfile.plugins");
+const SmartfileInterpreter = require("./smartfile.interpreter");
+exports.toFs = function (from, toPath) {
+    var done = plugins.Q.defer();
+    var stream = plugins.request(from).pipe(plugins.fsExtra.createWriteStream(toPath));
+    stream.on('finish', function () {
+        done.resolve(toPath);
+    });
+    return done.promise;
+};
+/**
+ *
+ * @param filePathArg
+ * @returns {*}
+ */
+exports.toGulpStreamSync = function (filePathArg, baseArg) {
+    let stream = plugins.g.remoteSrc(filePathArg, {
+        base: baseArg
+    });
+    return stream;
+};
+/**
+ *
+ * @param fromArg
+ * @returns {any}
+ */
+exports.toObject = function (fromArg) {
+    let done = plugins.Q.defer();
+    plugins.request.get(fromArg, function (error, response, bodyString) {
+        let returnObject;
+        if (!error && response.statusCode == 200) {
+            returnObject = SmartfileInterpreter.objectFile(bodyString, SmartfileInterpreter.filetype(fromArg));
+            done.resolve(returnObject);
+        }
+        else {
+            console.log('could not get remote file from ' + fromArg);
+            returnObject = undefined;
+            done.reject(returnObject);
+        }
+        ;
+    });
+    return done.promise;
+};
+/**
+ *
+ * @param fromArg
+ * @returns {any}
+ */
+exports.toString = (fromArg) => {
+    let done = plugins.Q.defer();
+    plugins.request.get(fromArg, function (error, response, bodyString) {
+        if (!error && response.statusCode == 200) {
+            done.resolve(bodyString);
+        }
+        else {
+            plugins.beautylog.error('could not get remote file from ' + fromArg);
+            bodyString = undefined;
+            done.reject(bodyString);
+        }
+        ;
+    });
+    return done.promise;
+};
+//# sourceMappingURL=data:application/json;base64,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

npmextra.json

@@ -1,45 +1,9 @@
 {
-  "npmdocker": {},
-  "npmci": {
-    "npmGlobalTools": [],
-    "npmAccessLevel": "public"
+  "npmts":{
+    "mode":"default",
+    "coverageTreshold":70
   },
-  "gitzone": {
-    "projectType": "npm",
-    "module": {
-      "githost": "code.foss.global",
-      "gitscope": "push.rocks",
-      "gitrepo": "smartfile",
-      "description": "Provides comprehensive tools for efficient file management in Node.js using TypeScript, including handling streams, virtual directories, and various file operations.",
-      "npmPackagename": "@push.rocks/smartfile",
-      "license": "MIT",
-      "keywords": [
-        "file management",
-        "TypeScript",
-        "Node.js",
-        "file operations",
-        "file manipulation",
-        "file streaming",
-        "virtual directory",
-        "filesystem utilities",
-        "memory-efficient file handling",
-        "custom file operations",
-        "write files",
-        "read files",
-        "copy files",
-        "delete files",
-        "list directories",
-        "handle large files",
-        "virtual filesystems",
-        "buffer operations"
-      ]
-    }
-  },
-  "tsdoc": {
-    "classes": ["SmartFile", "StreamFile"],
-    "descriptions": [
-      "the purpose of the StreamFile class is to provide a hybrid interface between streaming files and simple handling when writing and reading those files multiple times."
-    ],
-    "legal": "\n## License and Legal Information\n\nThis repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. \n\n**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.\n\n### Trademarks\n\nThis project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.\n\n### Company Information\n\nTask Venture Capital GmbH  \nRegistered at District court Bremen HRB 35230 HB, Germany\n\nFor any legal inquiries or if you require further information, please contact us via email at hello@task.vc.\n\nBy using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.\n"
+  "npmdocker":{
+    
   }
 }

package.json

@@ -1,88 +1,50 @@
 {
-  "name": "@push.rocks/smartfile",
-  "private": false,
-  "version": "13.0.1",
-  "description": "High-level file representation classes (SmartFile, StreamFile, VirtualDirectory) for efficient in-memory file management in Node.js using TypeScript. Works seamlessly with @push.rocks/smartfs for filesystem operations.",
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
-  "type": "module",
+  "name": "smartfile",
+  "version": "4.0.14",
+  "description": "offers smart ways to work with files in nodejs",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
   "scripts": {
-    "test": "(tstest test/ --verbose --logfile --timeout 120)",
-    "build": "(tsbuild --web --allowimplicitany)",
-    "buildDocs": "tsdoc"
+    "test": "(npmts)",
+    "reinstall": "(rm -r node_modules && npm install)",
+    "release": "(git pull origin master && npm version patch && git push origin master && git checkout release && git merge master && git push origin release && git checkout master)",
+    "update": "(git checkout master && git pull origin master && npm install)",
+    "upgrade": "(npm run update) && (ncu upgradeAll && npm install)"
   },
   "repository": {
     "type": "git",
-    "url": "https://code.foss.global/push.rocks/smartfile.git"
+    "url": "https://gitlab.com/pushrocks/smartfile.git"
   },
   "keywords": [
-    "file management",
-    "TypeScript",
-    "Node.js",
-    "in-memory files",
-    "SmartFile",
-    "StreamFile",
-    "VirtualDirectory",
-    "file representation",
-    "file streaming",
-    "virtual directory",
-    "file factory",
-    "memory-efficient file handling",
-    "buffer operations",
-    "file content manipulation"
+    "filesystem",
+    "json"
   ],
-  "author": "Lossless GmbH <hello@lossless.com> (https://lossless.com)",
+  "author": "Smart Coordination GmbH <office@push.rocks> (https://push.rocks)",
   "license": "MIT",
   "bugs": {
-    "url": "https://code.foss.global/push.rocks/smartfile/issues"
+    "url": "https://gitlab.com/pushrocks/smartfile/issues"
   },
-  "homepage": "https://code.foss.global/push.rocks/smartfile#readme",
+  "homepage": "https://gitlab.com/pushrocks/smartfile",
   "dependencies": {
-    "@push.rocks/lik": "^6.2.2",
-    "@push.rocks/smartdelay": "^3.0.5",
-    "@push.rocks/smartfile-interfaces": "^1.0.7",
-    "@push.rocks/smarthash": "^3.2.3",
-    "@push.rocks/smartjson": "^5.0.20",
-    "@push.rocks/smartmime": "^2.0.4",
-    "@push.rocks/smartpath": "^6.0.0",
-    "@push.rocks/smartpromise": "^4.2.3",
-    "@push.rocks/smartrequest": "^4.2.1",
-    "@push.rocks/smartstream": "^3.2.5",
-    "@types/js-yaml": "^4.0.9",
-    "glob": "^11.0.3",
-    "js-yaml": "^4.1.0"
-  },
-  "peerDependencies": {
-    "@push.rocks/smartfs": "^1.0.0"
-  },
-  "peerDependenciesMeta": {
-    "@push.rocks/smartfs": {
-      "optional": true
-    }
+    "@types/fs-extra": "0.x.x",
+    "@types/q": "0.x.x",
+    "beautylog": "^5.0.22",
+    "fs-extra": "^0.30.0",
+    "glob": "^7.0.6",
+    "gulp": "^3.9.1",
+    "gulp-remote-src": "^0.4.1",
+    "js-yaml": "^3.6.1",
+    "q": "^1.4.1",
+    "request": "^2.74.0",
+    "require-reload": "0.2.2",
+    "typings-global": "^1.0.14",
+    "vinyl": "^1.2.0",
+    "vinyl-file": "^2.0.0"
   },
   "devDependencies": {
-    "@git.zone/tsbuild": "^2.6.4",
-    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^2.3.4",
-    "@types/node": "^22.15.21"
-  },
-  "files": [
-    "ts/**/*",
-    "ts_web/**/*",
-    "dist/**/*",
-    "dist_*/**/*",
-    "dist_ts/**/*",
-    "dist_ts_web/**/*",
-    "assets/**/*",
-    "cli.js",
-    "npmextra.json",
-    "readme.md"
-  ],
-  "browserslist": [
-    "last 1 chrome versions"
-  ],
-  "packageManager": "pnpm@10.10.0+sha512.d615db246fe70f25dcfea6d8d73dee782ce23e2245e3c4f6f888249fb568149318637dca73c2c5c8ef2a4ca0d5657fb9567188bfab47f566d1ee6ce987815c39",
-  "pnpm": {
-    "overrides": {}
+    "gulp-function": "^1.3.6",
+    "npmts-g": "^5.2.8",
+    "should": "^11.1.0",
+    "typings-test": "^1.0.2"
   }
 }

readme.hints.md

@@ -1,168 +0,0 @@
-# SmartFile Implementation Hints
-
-## Major Architectural Change (v12.0.0)
-
-### Overview
-
-SmartFile has been refactored to focus exclusively on **in-memory file representations** (SmartFile, StreamFile, VirtualDirectory). All filesystem operations have been moved to or delegated to `@push.rocks/smartfs`.
-
-### Key Changes
-
-1. **Factory Pattern Introduction**
-   - New `SmartFileFactory` class introduced
-   - Factory is bound to a `SmartFs` instance (from `@push.rocks/smartfs`)
-   - All file instances are created through the factory
-   - Factory methods: `fromFilePath()`, `fromUrl()`, `fromBuffer()`, `fromString()`, etc.
-
-2. **SmartFile, StreamFile, VirtualDirectory**
-   - Now accept optional `smartFs` parameter in constructor
-   - Filesystem operations (write, read, delete) use `smartFs` if available
-   - Fallback to legacy methods if `smartFs` not provided (for backward compatibility)
-   - Static factory methods moved to `SmartFileFactory`
-
-3. **Separation of Concerns**
-   - **SmartFile** = In-memory file representation (path + content buffer)
-   - **StreamFile** = Lazy-loaded streaming file representation
-   - **VirtualDirectory** = Collection of SmartFiles in memory
-   - **SmartFs** (from @push.rocks/smartfs) = Filesystem operations
-
-### Usage Pattern
-
-```typescript
-import { SmartFileFactory } from '@push.rocks/smartfile';
-import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
-
-// Create factory with SmartFs instance
-const smartFs = new SmartFs(new SmartFsProviderNode());
-const factory = new SmartFileFactory(smartFs);
-
-// Or use default Node.js factory
-const factory = SmartFileFactory.nodeFs();
-
-// Create SmartFile through factory
-const file = await factory.fromFilePath('./data.json');
-await file.write(); // Uses bound smartFs instance
-
-// Create StreamFile
-const stream = await factory.streamFromPath('./large.zip');
-
-// Create VirtualDirectory
-const vdir = await factory.virtualDirectoryFromPath('./src');
-```
-
-### What Belongs Where
-
-**SmartFile/StreamFile/VirtualDirectory (this package)**:
-- ✅ In-memory file representation
-- ✅ Content manipulation (edit, parse, transform)
-- ✅ Loading content FROM sources (factory methods)
-- ✅ Saving content TO destinations (write methods)
-- ✅ Instance metadata (hash, size, mime type)
-- ✅ Collection operations (for VirtualDirectory)
-
-**SmartFs (@push.rocks/smartfs)**:
-- ✅ Filesystem queries (exists, stat)
-- ✅ File operations without content loading (copy, move)
-- ✅ Directory operations (list, create, delete)
-- ✅ Streaming operations (readStream, writeStream)
-- ✅ Provider abstraction (Node.js, memory, S3, etc.)
-
-### VirtualDirectory Collection Methods
-
-VirtualDirectory now has comprehensive collection methods:
-
-**Queries** (operate on in-memory collection):
-- `exists(path)` / `has(path)` - Check if path exists in collection
-- `getFileByPath(path)` - Get SmartFile from collection
-- `listFiles()` - List all SmartFiles
-- `listDirectories()` - List directory paths represented in collection
-- `filter(predicate)` - Filter SmartFiles
-- `map(fn)` - Transform SmartFiles
-- `find(predicate)` - Find SmartFile
-- `size()` - Number of files in collection
-- `isEmpty()` - Check if collection is empty
-
-**Mutations**:
-- `addSmartfiles(files)` - Add files to collection
-- `addSmartfile(file)` - Add single file
-- `removeByPath(path)` - Remove from collection
-- `clear()` - Empty collection
-- `merge(otherVDir)` - Merge another VirtualDirectory
-
-### Backward Compatibility
-
-- Legacy namespace exports (`fs`, `memory`, `fsStream`, `interpreter`) are **deprecated**
-- They remain functional for transition period but marked with `@deprecated`
-- Will be removed in future version
-- Users should migrate to `@push.rocks/smartfs` and `SmartFileFactory`
-
-### Migration Path
-
-**Old (deprecated)**:
-```typescript
-import * as smartfile from '@push.rocks/smartfile';
-
-const file = await smartfile.SmartFile.fromFilePath('./file.txt');
-await file.write();
-
-const exists = await smartfile.fs.fileExists('./file.txt');
-await smartfile.fs.copy('./a.txt', './b.txt');
-```
-
-**New (recommended)**:
-```typescript
-import { SmartFileFactory } from '@push.rocks/smartfile';
-import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
-
-const factory = SmartFileFactory.nodeFs();
-const file = await factory.fromFilePath('./file.txt');
-await file.write();
-
-const smartFs = new SmartFs(new SmartFsProviderNode());
-const exists = await smartFs.file('./file.txt').exists();
-await smartFs.file('./a.txt').copy('./b.txt');
-```
-
-### Testing Considerations
-
-- Tests should use `SmartFileFactory.nodeFs()` or create custom factory with memory provider
-- VirtualDirectory tests can use collection methods without filesystem access
-- Filesystem operations should be tested via `@push.rocks/smartfs`
-
-### Future Plans
-
-- Remove deprecated namespace exports completely
-- Full smartfs integration (remove fallback code)
-- Potentially remove fs-extra, glob dependencies once smartfs is fully integrated
-
-## listFileTree Function Enhancement (ts/fs.ts:367-415)
-
-### Issue Fixed
-
-The `listFileTree` function previously had inconsistent behavior with `**/*.extension` patterns across different systems and glob implementations. Some implementations would miss root-level files when using patterns like `**/*.ts`.
-
-### Solution Implemented
-
-Modified the function to explicitly handle `**/` patterns by:
-
-1. Detecting when a pattern starts with `**/`
-2. Extracting the file pattern after `**/` (e.g., `*.ts` from `**/*.ts`)
-3. Running both the original pattern and the extracted root pattern
-4. Using a Set to deduplicate results and ensure consistent ordering
-
-### Key Benefits
-
-- Guarantees consistent behavior across all systems
-- Ensures both root-level and nested files are found with `**/*` patterns
-- Maintains backward compatibility
-- No performance degradation due to efficient deduplication
-
-### Test Coverage
-
-Added comprehensive tests to verify:
-
-- Both root and nested files are found with `**/*.ts`
-- No duplicate entries in results
-- Edge cases with various file extensions work correctly
-
-This fix ensures tools like `tsbuild check **/*.ts` work reliably across all systems.

readme.md

@@ -1,511 +0,0 @@
-# @push.rocks/smartfile 📁
-
-> **High-level file representation classes for Node.js**
-
-## 🚀 What is smartfile?
-
-`@push.rocks/smartfile` provides powerful **in-memory file representations** for Node.js applications. It offers clean, TypeScript-first classes for working with files (`SmartFile`), streams (`StreamFile`), and virtual file collections (`VirtualDirectory`).
-
-Think of it as your go-to solution for **content manipulation**, **file transformations**, and **in-memory file operations** - all while seamlessly integrating with [@push.rocks/smartfs](https://code.foss.global/push.rocks/smartfs) for actual filesystem operations.
-
-## Issue Reporting and Security
-
-For reporting bugs, issues, or security vulnerabilities, please visit [community.foss.global/](https://community.foss.global/). This is the central community hub for all issue reporting. Developers who want to sign a contribution agreement and go through identification can also get a [code.foss.global/](https://code.foss.global/) account to submit Pull Requests directly.
-
-## 💾 Installation
-
-```bash
-pnpm install @push.rocks/smartfile
-# Optional: Install smartfs for filesystem operations
-pnpm install @push.rocks/smartfs
-```
-
-## ✨ Key Features
-
-- 🎯 **Factory Pattern** - Clean, consistent API for creating file instances
-- 🔥 **Streaming Support** - Handle massive files efficiently with `StreamFile`
-- 📦 **Virtual Directories** - Work with in-memory file collections
-- 🌐 **URL Support** - Directly fetch files from URLs
-- 🎨 **Content Manipulation** - Edit, transform, and parse file content
-- ⚡ **TypeScript First** - Full type safety and IntelliSense support
-- 🛠️ **Comprehensive Collection API** - Filter, map, find files in virtual directories
-
-## 📚 Quick Start
-
-### Using the Factory
-
-```typescript
-import { SmartFileFactory } from '@push.rocks/smartfile';
-
-// Create factory (uses Node.js filesystem by default)
-const factory = SmartFileFactory.nodeFs();
-
-// Load a file into memory
-const file = await factory.fromFilePath('./config.json');
-
-// Edit content
-await file.editContentAsString(async (content) => {
-  return content.toUpperCase();
-});
-
-// Save back to disk
-await file.write();
-```
-
-### With SmartFs Integration
-
-```typescript
-import { SmartFileFactory } from '@push.rocks/smartfile';
-import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
-
-// Create SmartFs instance with provider
-const smartFs = new SmartFs(new SmartFsProviderNode());
-
-// Create factory bound to this filesystem
-const factory = new SmartFileFactory(smartFs);
-
-// Now all file operations use the smartfs instance
-const file = await factory.fromFilePath('./data.json');
-await file.write(); // Uses smartfs under the hood
-```
-
-## 🎨 Core Components
-
-### SmartFileFactory
-
-The factory is your entry point for creating all file instances:
-
-```typescript
-import { SmartFileFactory } from '@push.rocks/smartfile';
-
-const factory = SmartFileFactory.nodeFs();
-
-// Create from various sources
-const fileFromPath = await factory.fromFilePath('./data.json');
-const fileFromUrl = await factory.fromUrl('https://example.com/config.json');
-const fileFromBuffer = factory.fromBuffer('./file.txt', Buffer.from('content'));
-const fileFromString = factory.fromString('./file.txt', 'Hello World', 'utf8');
-
-// Create StreamFile instances
-const stream = await factory.streamFromPath('./large-file.zip');
-const streamFromUrl = await factory.streamFromUrl('https://example.com/video.mp4');
-
-// Create VirtualDirectory instances
-const vdir = await factory.virtualDirectoryFromPath('./src');
-const emptyVdir = factory.virtualDirectoryEmpty();
-```
-
-### SmartFile Class
-
-Represents a single file loaded in memory:
-
-```typescript
-// Created via factory
-const file = await factory.fromFilePath('./data.json');
-
-// Content access
-const asString = file.parseContentAsString();
-const asBuffer = file.parseContentAsBuffer();
-
-// Content manipulation
-await file.editContentAsString(async (content) => {
-  const data = JSON.parse(content);
-  data.updated = new Date().toISOString();
-  return JSON.stringify(data, null, 2);
-});
-
-// File operations
-await file.write();                          // Save to original location
-await file.writeToDiskAtPath('./output.json'); // Save to specific path
-await file.writeToDir('./dist');            // Save to directory
-await file.read();                           // Reload from disk
-await file.delete();                         // Delete from disk
-
-// Metadata
-const size = await file.getSize();           // File size in bytes
-const hash = await file.getHash('content');  // SHA256 hash
-const stream = file.getStream();             // Get as Node.js stream
-
-// Path information
-console.log(file.path);                      // Relative path
-console.log(file.absolutePath);              // Absolute path
-console.log(file.parsedPath);                // Parsed path components
-```
-
-### StreamFile Class
-
-Perfect for handling large files without memory overhead:
-
-```typescript
-// Created via factory
-const streamFile = await factory.streamFromPath('./bigfile.zip');
-
-// Or from URL
-const urlStream = await factory.streamFromUrl('https://example.com/large.mp4');
-
-// Or from buffer
-const bufferStream = factory.streamFromBuffer(Buffer.from('content'));
-
-// Write to disk (streams the content)
-await streamFile.writeToDisk('./output/bigfile.zip');
-await streamFile.writeToDir('./output');
-
-// Get content (loads into memory - use carefully!)
-const buffer = await streamFile.getContentAsBuffer();
-const string = await streamFile.getContentAsString('utf8');
-
-// Get as Node.js stream for piping
-const readStream = await streamFile.createReadStream();
-
-// Convert to SmartFile (loads into memory)
-const smartFile = await streamFile.toSmartFile();
-
-// Get file size
-const size = await streamFile.getSize();
-```
-
-### VirtualDirectory Class
-
-Manage collections of SmartFiles in memory:
-
-```typescript
-// Created via factory
-const vdir = await factory.virtualDirectoryFromPath('./src');
-
-// Or create empty
-const emptyVdir = factory.virtualDirectoryEmpty();
-
-// Or from file array
-const files = [file1, file2, file3];
-const vdirFromFiles = factory.virtualDirectoryFromFileArray(files);
-
-// ============================================
-// Collection Queries (in-memory operations)
-// ============================================
-
-// Check existence in collection
-if (vdir.exists('components/Button.tsx')) {
-  console.log('File exists in virtual directory');
-}
-
-// Get file from collection
-const file = await vdir.getFileByPath('utils/helpers.ts');
-
-// List all files
-const allFiles = vdir.listFiles();
-
-// List directory paths represented in collection
-const dirs = vdir.listDirectories();
-
-// Filter files
-const tsFiles = vdir.filter(f => f.path.endsWith('.ts'));
-const largeFiles = vdir.filter(f => f.contentBuffer.length > 10000);
-
-// Map/transform files
-const uppercased = vdir.map(f => {
-  f.contentBuffer = Buffer.from(f.parseContentAsString().toUpperCase());
-  return f;
-});
-
-// Find specific file
-const configFile = vdir.find(f => f.path.includes('config'));
-
-// Collection info
-const fileCount = vdir.size();
-const empty = vdir.isEmpty();
-
-// ============================================
-// Collection Mutations
-// ============================================
-
-// Add files
-vdir.addSmartfile(newFile);
-vdir.addSmartfiles([file1, file2, file3]);
-
-// Remove file
-vdir.removeByPath('old-file.ts');
-
-// Clear all files
-vdir.clear();
-
-// Merge another virtual directory
-vdir.merge(otherVirtualDir);
-
-// ============================================
-// Load/Save (filesystem bridge operations)
-// ============================================
-
-// Save all files to disk
-await vdir.saveToDisk('./dist');
-
-// Reload from disk
-await vdir.loadFromDisk('./src');
-
-// Work with subdirectories
-const subVdir = await vdir.shiftToSubdirectory('components');
-await vdir.addVirtualDirectory(otherVdir, 'lib');
-```
-
-## 🔄 Integration with SmartFs
-
-For filesystem operations beyond loading/saving content, use [@push.rocks/smartfs](https://code.foss.global/push.rocks/smartfs):
-
-```typescript
-import { SmartFileFactory } from '@push.rocks/smartfile';
-import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
-
-const smartFs = new SmartFs(new SmartFsProviderNode());
-const factory = new SmartFileFactory(smartFs);
-
-// Use smartfile for content manipulation
-const file = await factory.fromFilePath('./config.json');
-await file.editContentAsString(async (s) => s.toUpperCase());
-await file.write();
-
-// Use smartfs for filesystem operations
-const exists = await smartFs.file('./config.json').exists();
-await smartFs.file('./config.json').copy('./config.backup.json');
-const stats = await smartFs.file('./config.json').stat();
-
-// List directory with smartfs
-const entries = await smartFs.directory('./src').list();
-```
-
-## 🌟 Common Use Cases
-
-### Configuration File Management
-
-```typescript
-const factory = SmartFileFactory.nodeFs();
-
-// Load, modify, and save config
-const config = await factory.fromFilePath('./package.json');
-await config.editContentAsString(async (content) => {
-  const pkg = JSON.parse(content);
-  pkg.version = '2.0.0';
-  return JSON.stringify(pkg, null, 2);
-});
-await config.write();
-```
-
-### Batch File Processing
-
-```typescript
-const factory = SmartFileFactory.nodeFs();
-
-// Load directory into virtual collection
-const vdir = await factory.virtualDirectoryFromPath('./content');
-
-// Process all markdown files
-const mdFiles = vdir.filter(f => f.path.endsWith('.md'));
-for (const file of mdFiles.listFiles()) {
-  await file.editContentAsString(async (content) => {
-    // Add frontmatter, transform links, etc.
-    return `---\nprocessed: true\n---\n\n${content}`;
-  });
-}
-
-// Save processed files
-await vdir.saveToDisk('./dist/content');
-```
-
-### Download and Process Remote Files
-
-```typescript
-const factory = SmartFileFactory.nodeFs();
-
-// Fetch from URL
-const remoteFile = await factory.fromUrl('https://api.example.com/data.json');
-
-// Process content
-await remoteFile.editContentAsString(async (content) => {
-  const data = JSON.parse(content);
-  // Transform data
-  return JSON.stringify(data.results, null, 2);
-});
-
-// Save locally
-await remoteFile.writeToDiskAtPath('./cache/data.json');
-```
-
-### Large File Streaming
-
-```typescript
-const factory = SmartFileFactory.nodeFs();
-
-// Download large file as stream
-const largeFile = await factory.streamFromUrl('https://example.com/large-dataset.csv');
-
-// Save to disk (streams, doesn't load all into memory)
-await largeFile.writeToDisk('./data/dataset.csv');
-
-// Or get size without downloading entire file
-const size = await largeFile.getSize();
-console.log(`File size: ${size} bytes`);
-```
-
-### Virtual File System for Testing
-
-```typescript
-import { SmartFileFactory } from '@push.rocks/smartfile';
-import { SmartFs, SmartFsProviderMemory } from '@push.rocks/smartfs';
-
-// Use in-memory filesystem for tests
-const memoryFs = new SmartFs(new SmartFsProviderMemory());
-const factory = new SmartFileFactory(memoryFs);
-
-// Create virtual files
-const testFile = factory.fromString('test.txt', 'test content');
-await testFile.write(); // Writes to in-memory filesystem
-
-// Test your code without touching real filesystem
-```
-
-## 🏗️ Architecture
-
-### Responsibility Split
-
-**@push.rocks/smartfile** (this package):
-- ✅ In-memory file representations (SmartFile, StreamFile, VirtualDirectory)
-- ✅ Content manipulation and transformation
-- ✅ Loading content FROM sources (disk, URL, buffer, string)
-- ✅ Saving content TO destinations (disk, stream)
-- ✅ Collection operations (filter, map, find on VirtualDirectory)
-
-**@push.rocks/smartfs**:
-- ✅ Low-level filesystem operations (exists, stat, copy, move, delete)
-- ✅ Directory operations (list, create, remove)
-- ✅ Provider abstraction (Node.js fs, in-memory, S3, etc.)
-- ✅ Streaming (readStream, writeStream)
-- ✅ Transactions and file watching
-
-## 📖 API Reference
-
-### SmartFileFactory
-
-| Method | Description |
-|--------|-------------|
-| `SmartFileFactory.nodeFs()` | Create factory with Node.js filesystem provider |
-| `new SmartFileFactory(smartFs)` | Create factory with custom SmartFs instance |
-| `factory.fromFilePath(path, base?)` | Load file from disk into SmartFile |
-| `factory.fromUrl(url)` | Fetch file from URL into SmartFile |
-| `factory.fromBuffer(path, buffer, base?)` | Create SmartFile from Buffer |
-| `factory.fromString(path, content, encoding, base?)` | Create SmartFile from string |
-| `factory.streamFromPath(path)` | Create StreamFile from disk |
-| `factory.streamFromUrl(url)` | Create StreamFile from URL |
-| `factory.streamFromBuffer(buffer, path?)` | Create StreamFile from Buffer |
-| `factory.virtualDirectoryFromPath(path)` | Load directory into VirtualDirectory |
-| `factory.virtualDirectoryEmpty()` | Create empty VirtualDirectory |
-| `factory.virtualDirectoryFromFileArray(files)` | Create VirtualDirectory from SmartFiles |
-
-### SmartFile Instance Methods
-
-| Method | Description |
-|--------|-------------|
-| `file.write()` | Save to original location |
-| `file.writeToDiskAtPath(path)` | Save to specific path |
-| `file.writeToDir(dir)` | Save to directory (preserves relative path) |
-| `file.read()` | Reload content from disk |
-| `file.delete()` | Delete file from disk |
-| `file.editContentAsString(fn)` | Transform content as string |
-| `file.parseContentAsString(encoding?)` | Get content as string |
-| `file.parseContentAsBuffer()` | Get content as Buffer |
-| `file.getHash(type?)` | Get SHA256 hash ('path', 'content', 'all') |
-| `file.getSize()` | Get content size in bytes |
-| `file.getStream()` | Get content as Node.js Readable stream |
-
-### StreamFile Instance Methods
-
-| Method | Description |
-|--------|-------------|
-| `stream.writeToDisk(path)` | Stream content to disk |
-| `stream.writeToDir(dir)` | Stream to directory |
-| `stream.createReadStream()` | Get as Node.js Readable stream |
-| `stream.getContentAsBuffer()` | Load entire content into Buffer |
-| `stream.getContentAsString(encoding?)` | Load entire content as string |
-| `stream.getSize()` | Get content size in bytes |
-| `stream.toSmartFile()` | Convert to SmartFile (loads into memory) |
-
-### VirtualDirectory Instance Methods
-
-**Collection Queries:**
-| Method | Description |
-|--------|-------------|
-| `vdir.exists(path)` | Check if file exists in collection |
-| `vdir.has(path)` | Alias for exists() |
-| `vdir.getFileByPath(path)` | Get SmartFile by path |
-| `vdir.listFiles()` | Get all SmartFiles |
-| `vdir.listDirectories()` | Get all directory paths |
-| `vdir.filter(predicate)` | Filter files, returns new VirtualDirectory |
-| `vdir.map(fn)` | Transform files, returns new VirtualDirectory |
-| `vdir.find(predicate)` | Find first matching file |
-| `vdir.size()` | Get file count |
-| `vdir.isEmpty()` | Check if empty |
-
-**Collection Mutations:**
-| Method | Description |
-|--------|-------------|
-| `vdir.addSmartfile(file)` | Add single file |
-| `vdir.addSmartfiles(files)` | Add multiple files |
-| `vdir.removeByPath(path)` | Remove file by path |
-| `vdir.clear()` | Remove all files |
-| `vdir.merge(otherVdir)` | Merge another VirtualDirectory |
-
-**Load/Save:**
-| Method | Description |
-|--------|-------------|
-| `vdir.saveToDisk(dir)` | Write all files to disk |
-| `vdir.loadFromDisk(dir)` | Load files from disk (replaces collection) |
-
-## 🔧 TypeScript Support
-
-Full TypeScript support with comprehensive type definitions:
-
-```typescript
-import type { SmartFile, StreamFile, VirtualDirectory, SmartFileFactory } from '@push.rocks/smartfile';
-
-const processFile = async (file: SmartFile): Promise<void> => {
-  const content = file.parseContentAsString();
-  // TypeScript knows content is string
-};
-```
-
-## 📦 Backward Compatibility
-
-Version 12.0.0 introduces the factory pattern. Legacy exports are deprecated but still functional:
-
-```typescript
-// ⚠️ Deprecated (still works, but will be removed)
-import * as smartfile from '@push.rocks/smartfile';
-const file = await smartfile.SmartFile.fromFilePath('./file.txt');
-await smartfile.fs.copy('./a.txt', './b.txt');
-
-// ✅ Recommended (new factory pattern)
-import { SmartFileFactory } from '@push.rocks/smartfile';
-const factory = SmartFileFactory.nodeFs();
-const file = await factory.fromFilePath('./file.txt');
-
-// For filesystem operations, use smartfs:
-import { SmartFs, SmartFsProviderNode } from '@push.rocks/smartfs';
-const smartFs = new SmartFs(new SmartFsProviderNode());
-await smartFs.file('./a.txt').copy('./b.txt');
-```
-
-## License and Legal Information
-
-This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository.
-
-**Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
-
-### Trademarks
-
-This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
-
-### Company Information
-
-Task Venture Capital GmbH
-Registered at District court Bremen HRB 35230 HB, Germany
-
-For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
-
-By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.

test/helpers/mock-smartfs.ts

@@ -1,181 +0,0 @@
-/**
- * Mock SmartFs implementation for testing
- * Provides fluent API matching @push.rocks/smartfs using native Node.js fs
- */
-import { promises as fsPromises, createReadStream, createWriteStream } from 'fs';
-import * as path from 'path';
-import { Readable, Writable } from 'stream';
-
-/**
- * Mock SmartFsFile - Fluent file operations builder
- */
-class MockSmartFsFile {
-  private filePath: string;
-  private options: {
-    encoding?: BufferEncoding;
-    recursive?: boolean;
-  } = {};
-
-  constructor(filePath: string) {
-    this.filePath = filePath;
-  }
-
-  // Configuration methods (return this for chaining)
-  public encoding(encoding: BufferEncoding): this {
-    this.options.encoding = encoding;
-    return this;
-  }
-
-  public recursive(): this {
-    this.options.recursive = true;
-    return this;
-  }
-
-  // Action methods (return Promises)
-  public async read(): Promise<string | Buffer> {
-    if (this.options.encoding) {
-      return await fsPromises.readFile(this.filePath, this.options.encoding);
-    }
-    return await fsPromises.readFile(this.filePath);
-  }
-
-  public async write(content: string | Buffer): Promise<void> {
-    // Ensure directory exists
-    const dirPath = path.dirname(this.filePath);
-    await fsPromises.mkdir(dirPath, { recursive: true });
-
-    if (this.options.encoding && typeof content === 'string') {
-      await fsPromises.writeFile(this.filePath, content, this.options.encoding);
-    } else {
-      await fsPromises.writeFile(this.filePath, content);
-    }
-  }
-
-  public async exists(): Promise<boolean> {
-    try {
-      await fsPromises.access(this.filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  public async delete(): Promise<void> {
-    await fsPromises.unlink(this.filePath);
-  }
-
-  public async stat(): Promise<any> {
-    return await fsPromises.stat(this.filePath);
-  }
-
-  public async readStream(): Promise<Readable> {
-    return createReadStream(this.filePath);
-  }
-
-  public async writeStream(): Promise<Writable> {
-    // Ensure directory exists
-    const dirPath = path.dirname(this.filePath);
-    await fsPromises.mkdir(dirPath, { recursive: true });
-    return createWriteStream(this.filePath);
-  }
-
-  public async copy(dest: string): Promise<void> {
-    await fsPromises.copyFile(this.filePath, dest);
-  }
-}
-
-/**
- * Mock SmartFsDirectory - Fluent directory operations builder
- */
-class MockSmartFsDirectory {
-  private dirPath: string;
-  private options: {
-    recursive?: boolean;
-  } = {};
-
-  constructor(dirPath: string) {
-    this.dirPath = dirPath;
-  }
-
-  // Configuration methods (return this for chaining)
-  public recursive(): this {
-    this.options.recursive = true;
-    return this;
-  }
-
-  // Action methods (return Promises)
-  public async list(): Promise<Array<{ path: string; isFile: boolean; isDirectory: boolean }>> {
-    const entries: Array<{ path: string; isFile: boolean; isDirectory: boolean }> = [];
-
-    if (this.options.recursive) {
-      // Recursive listing
-      const walk = async (dir: string) => {
-        const items = await fsPromises.readdir(dir);
-        for (const item of items) {
-          const fullPath = path.join(dir, item);
-          const stats = await fsPromises.stat(fullPath);
-
-          if (stats.isFile()) {
-            entries.push({ path: fullPath, isFile: true, isDirectory: false });
-          } else if (stats.isDirectory()) {
-            entries.push({ path: fullPath, isFile: false, isDirectory: true });
-            await walk(fullPath);
-          }
-        }
-      };
-      await walk(this.dirPath);
-    } else {
-      // Non-recursive listing
-      const items = await fsPromises.readdir(this.dirPath);
-      for (const item of items) {
-        const fullPath = path.join(this.dirPath, item);
-        const stats = await fsPromises.stat(fullPath);
-        entries.push({
-          path: fullPath,
-          isFile: stats.isFile(),
-          isDirectory: stats.isDirectory(),
-        });
-      }
-    }
-
-    return entries;
-  }
-
-  public async create(): Promise<void> {
-    if (this.options.recursive) {
-      await fsPromises.mkdir(this.dirPath, { recursive: true });
-    } else {
-      await fsPromises.mkdir(this.dirPath);
-    }
-  }
-
-  public async exists(): Promise<boolean> {
-    try {
-      const stats = await fsPromises.stat(this.dirPath);
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
-  }
-
-  public async delete(): Promise<void> {
-    if (this.options.recursive) {
-      await fsPromises.rm(this.dirPath, { recursive: true, force: true });
-    } else {
-      await fsPromises.rmdir(this.dirPath);
-    }
-  }
-}
-
-/**
- * Mock SmartFs - Main class matching @push.rocks/smartfs API
- */
-export class MockSmartFs {
-  public file(filePath: string): MockSmartFsFile {
-    return new MockSmartFsFile(filePath);
-  }
-
-  public directory(dirPath: string): MockSmartFsDirectory {
-    return new MockSmartFsDirectory(dirPath);
-  }
-}

test/mytest.json

@@ -5,3 +5,4 @@
     "nestedkey1": "hello"
   }
 }
+

test/test.d.ts

@@ -0,0 +1 @@
+import "typings-test";

test/test.streamfile.ts

@@ -1,155 +0,0 @@
-import * as path from 'path';
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import * as smartfile from '../ts/index.js';
-import { MockSmartFs } from './helpers/mock-smartfs.js';
-
-// Create factory with MockSmartFs
-const mockFs = new MockSmartFs();
-const factory = new smartfile.SmartFileFactory(mockFs);
-
-// Test assets path
-const testAssetsPath = './test/testassets/';
-
-// ---------------------------
-// StreamFile Factory Tests
-// ---------------------------
-
-tap.test(
-  'SmartFileFactory.streamFromPath() -> should create a StreamFile from a file path',
-  async () => {
-    const streamFile = await factory.streamFromPath(
-      path.join(testAssetsPath, 'mytest.json'),
-    );
-    expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
-    const contentBuffer = await streamFile.getContentAsBuffer();
-    expect(contentBuffer).toBeInstanceOf(Buffer);
-  },
-);
-
-tap.test(
-  'SmartFileFactory.streamFromBuffer() -> should create a StreamFile from a Buffer',
-  async () => {
-    const buffer = Buffer.from('Some content');
-    const streamFile = factory.streamFromBuffer(
-      buffer,
-      'bufferfile.txt',
-    );
-    expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
-    const content = await streamFile.getContentAsBuffer();
-    expect(content.toString()).toEqual('Some content');
-  },
-);
-
-tap.test(
-  'SmartFileFactory.streamFromStream() -> should create a StreamFile from a stream',
-  async () => {
-    const { Readable } = await import('stream');
-    const stream = new Readable();
-    stream.push('stream content');
-    stream.push(null);
-
-    const streamFile = factory.streamFromStream(stream, 'streamfile.txt', false);
-    expect(streamFile).toBeInstanceOf(smartfile.StreamFile);
-  },
-);
-
-// ---------------------------
-// StreamFile Instance Tests
-// ---------------------------
-
-tap.test('StreamFile -> should write the stream to disk', async () => {
-  const streamFile = await factory.streamFromPath(
-    path.join(testAssetsPath, 'mytest.json'),
-  );
-  const targetPath = path.join(testAssetsPath, 'temp', 'stream-mytest.json');
-  await streamFile.writeToDisk(targetPath);
-
-  // Verify the file was written by reading it back
-  const verifyFile = await factory.fromFilePath(targetPath);
-  expect(verifyFile.contentBuffer).toBeInstanceOf(Buffer);
-});
-
-tap.test('StreamFile -> should write to a directory', async () => {
-  const streamFile = await factory.streamFromPath(
-    path.join(testAssetsPath, 'mytest.json'),
-  );
-  // Set relative path so writeToDir knows where to put it
-  streamFile.relativeFilePath = 'mytest-fromdir.json';
-  await streamFile.writeToDir(path.join(testAssetsPath, 'temp'));
-
-  // Verify the file was written
-  const targetPath = path.join(testAssetsPath, 'temp', 'mytest-fromdir.json');
-  const verifyFile = await factory.fromFilePath(targetPath);
-  expect(verifyFile.contentBuffer).toBeInstanceOf(Buffer);
-});
-
-tap.test('StreamFile -> should return content as a buffer', async () => {
-  const streamFile = await factory.streamFromPath(
-    path.join(testAssetsPath, 'mytest.json'),
-  );
-  const contentBuffer = await streamFile.getContentAsBuffer();
-  expect(contentBuffer).toBeInstanceOf(Buffer);
-});
-
-tap.test('StreamFile -> should return content as a string', async () => {
-  const streamFile = await factory.streamFromPath(
-    path.join(testAssetsPath, 'mytest.json'),
-  );
-  const contentString = await streamFile.getContentAsString();
-  expect(contentString).toBeTypeofString();
-
-  // Verify the content matches what's expected
-  const parsed = JSON.parse(contentString);
-  expect(parsed.key1).toEqual('this works');
-});
-
-tap.test('StreamFile -> should get size', async () => {
-  const buffer = Buffer.from('test content for size');
-  const streamFile = factory.streamFromBuffer(buffer, 'sizefile.txt');
-  const size = await streamFile.getSize();
-  expect(size).toEqual(buffer.length);
-});
-
-tap.test('StreamFile -> should handle multi-use streams', async () => {
-  const buffer = Buffer.from('multi-use content');
-  const streamFile = factory.streamFromBuffer(buffer, 'multiuse.txt');
-  streamFile.multiUse = true;
-
-  // Read multiple times
-  const content1 = await streamFile.getContentAsString();
-  const content2 = await streamFile.getContentAsString();
-
-  expect(content1).toEqual('multi-use content');
-  expect(content2).toEqual('multi-use content');
-});
-
-tap.test('StreamFile -> should convert to SmartFile', async () => {
-  const buffer = Buffer.from('convert to smartfile');
-  const streamFile = factory.streamFromBuffer(buffer, 'convert.txt');
-
-  const smartFile = await streamFile.toSmartFile();
-  expect(smartFile).toBeInstanceOf(smartfile.SmartFile);
-  expect(smartFile.parseContentAsString()).toEqual('convert to smartfile');
-});
-
-tap.test('StreamFile -> should create readable stream', async () => {
-  const buffer = Buffer.from('readable stream content');
-  const streamFile = factory.streamFromBuffer(buffer, 'readable.txt');
-
-  const stream = await streamFile.createReadStream();
-  expect(stream).toHaveProperty('pipe');
-
-  // Read from stream
-  const chunks: Buffer[] = [];
-  stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-
-  await new Promise((resolve) => {
-    stream.on('end', resolve);
-  });
-
-  const content = Buffer.concat(chunks).toString();
-  expect(content).toEqual('readable stream content');
-});
-
-// Start the test sequence
-tap.start();

test/test.ts

@@ -1,142 +1,226 @@
-import * as smartfile from '../ts/index.js';
-import { expect, tap } from '@git.zone/tstest/tapbundle';
-import { MockSmartFs } from './helpers/mock-smartfs.js';
+import "typings-test";
+import * as smartfile from "../dist/index";
+import beautylog = require("beautylog");
+let gulp = require("gulp");
+let gFunction = require("gulp-function");
+import path = require("path");
+import should = require("should");
+let vinyl = require("vinyl");
 
-// Create factory with MockSmartFs
-const mockFs = new MockSmartFs();
-const factory = new smartfile.SmartFileFactory(mockFs);
-
-// ---------------------------
-// SmartFileFactory Tests
-// ---------------------------
-
-tap.test('SmartFileFactory.nodeFs() -> should create a default factory', async () => {
-  const defaultFactory = smartfile.SmartFileFactory.nodeFs();
-  expect(defaultFactory).toBeInstanceOf(smartfile.SmartFileFactory);
-});
-
-tap.test('SmartFileFactory.fromFilePath() -> should create a SmartFile from file path', async () => {
-  const smartFile = await factory.fromFilePath('./test/testassets/mytest.json', process.cwd());
-  expect(smartFile).toBeInstanceOf(smartfile.SmartFile);
-  expect(smartFile.path).toEqual('test/testassets/mytest.json');
-  expect(smartFile.contentBuffer).toBeInstanceOf(Buffer);
-});
-
-tap.test('SmartFileFactory.fromBuffer() -> should create a SmartFile from buffer', async () => {
-  const buffer = Buffer.from('test content');
-  const smartFile = factory.fromBuffer('./test.txt', buffer);
-  expect(smartFile).toBeInstanceOf(smartfile.SmartFile);
-  expect(smartFile.contentBuffer.toString()).toEqual('test content');
-});
-
-tap.test('SmartFileFactory.fromString() -> should create a SmartFile from string', async () => {
-  const smartFile = factory.fromString('./test.txt', 'test content');
-  expect(smartFile).toBeInstanceOf(smartfile.SmartFile);
-  expect(smartFile.parseContentAsString()).toEqual('test content');
-});
-
-tap.test('SmartFileFactory.fromUrl() -> should create a SmartFile from URL', async () => {
-  // Note: This test would need a real HTTP endpoint or mock
-  // For now, we'll skip it or test with a known URL
-  // const smartFile = await factory.fromUrl('https://example.com/test.json');
-  // expect(smartFile).toBeInstanceOf(smartfile.SmartFile);
-});
-
-// ---------------------------
-// SmartFile Instance Tests
-// ---------------------------
-
-tap.test('SmartFile -> should produce vinyl compatible files', async () => {
-  const smartFile = await factory.fromFilePath('./test/testassets/mytest.json');
-  expect(smartFile).toBeInstanceOf(smartfile.SmartFile);
-  expect(smartFile.contents).toBeInstanceOf(Buffer);
-  expect(smartFile.isBuffer()).toBeTrue();
-  expect(smartFile.isDirectory()).toBeFalse();
-  expect(smartFile.isNull()).toBeFalse();
-});
-
-tap.test('SmartFile -> should write to disk', async () => {
-  const fileString = 'hi there';
-  const filePath = './test/testassets/temp/utf8.txt';
-  const smartFile = factory.fromString(filePath, fileString, 'utf8');
-  await smartFile.writeToDiskAtPath(filePath);
-
-  // Read it back
-  const smartFile2 = await factory.fromFilePath(filePath);
-  const retrievedString = smartFile2.parseContentAsString();
-  expect(retrievedString).toEqual(fileString);
-});
-
-tap.test('SmartFile -> should get a hash', async () => {
-  const fileString = 'hi there';
-  const smartFile = factory.fromString('./test/testassets/utf8.txt', fileString, 'utf8');
-  const hash = await smartFile.getHash();
-  expect(hash).toBeTypeofString();
-  expect(hash.length).toBeGreaterThan(0);
-});
-
-tap.test('SmartFile -> should update file name', async () => {
-  const smartFile = factory.fromString('./test/oldname.txt', 'content');
-  smartFile.updateFileName('newname.txt');
-  expect(smartFile.parsedPath.base).toEqual('newname.txt');
-});
-
-tap.test('SmartFile -> should edit content as string', async () => {
-  const smartFile = factory.fromString('./test.txt', 'original content');
-  await smartFile.editContentAsString(async (content) => {
-    return content.replace('original', 'modified');
+describe("smartfile".yellow,function(){
+    describe(".fs".yellow,function(){
+        describe(".fileExistsSync".yellow,function(){
+            it("should return an accurate boolean",function(){
+                (smartfile.fs.fileExistsSync("./test/mytest.json")).should.be.true();
+                (smartfile.fs.fileExistsSync("./test/notthere.json")).should.be.false();
             });
-  expect(smartFile.parseContentAsString()).toEqual('modified content');
-});
+        });
+        describe(".fileExists".yellow,function(){
+            it("should return a working promise",function(){
+                (smartfile.fs.fileExists("./test/mytest.json")).should.be.Promise();
+                (smartfile.fs.fileExists("./test/mytest.json")).should.be.fulfilled();
+                (smartfile.fs.fileExists("./test/notthere.json")).should.not.be.fulfilled();
+            });
+        });
+        describe(".listFoldersSync()",function(){
+            it("should get the file type from a string",function(){
+                smartfile.fs.listFoldersSync("./test/").should.containDeep([ "testfolder"]);
+                smartfile.fs.listFoldersSync("./test/").should.not.containDeep([ "notExistentFolder"]);
+            });
+        });
+        describe(".listFolders()",function(){
+            it("should get the file type from a string",function(done){
+                smartfile.fs.listFolders("./test/")
+                    .then(function(folderArrayArg){
+                        folderArrayArg.should.containDeep([ "testfolder"]);
+                        folderArrayArg.should.not.containDeep([ "notExistentFolder"]);
+                        done();
+                    });
+            });
+        });
+        describe(".listFilesSync()",function(){
+            it("should get the file type from a string",function(){
+                smartfile.fs.listFilesSync("./test/").should.containDeep([ "mytest.json"]);
+                smartfile.fs.listFilesSync("./test/").should.not.containDeep([ "notExistentFile"]);
+                smartfile.fs.listFilesSync("./test/",/mytest\.json/).should.containDeep([ "mytest.json"]);
+                smartfile.fs.listFilesSync("./test/",/mytests.json/).should.not.containDeep([ "mytest.json"]);
+            });
+        });
+        describe(".listFiles()",function(){
+            it("should get the file type from a string",function(done){
+                smartfile.fs.listFiles("./test/")
+                    .then(function(folderArrayArg){
+                        folderArrayArg.should.containDeep([ "mytest.json"]);
+                        folderArrayArg.should.not.containDeep([ "notExistentFile"]);
+                        done();
+                    });
+            });
+        });
+        describe(".listFileTree()",function(){
+            it("should get a file tree",function(done){
+                smartfile.fs.listFileTree(path.resolve("./test/"),"**/*.txt")
+                    .then(function(folderArrayArg){
+                        folderArrayArg.should.containDeep([ "testfolder/testfile1.txt"]);
+                        folderArrayArg.should.not.containDeep([ "mytest.json"]);
+                        done();
+                    });
+            });
+        });
+        describe(".copy()".yellow,function(){
+            it("should copy a directory",function(){
+                smartfile.fs.copy("./test/testfolder/","./test/temp/")
+            });
+            it("should copy a file",function(){
+                smartfile.fs.copy("./test/mytest.yaml","./test/temp/")
+            });
+            it("should copy a file and rename it",function(){
+                smartfile.fs.copy("./test/mytest.yaml","./test/temp/mytestRenamed.yaml")
+            });
+        });
+        describe(".remove()",function(){
+            it("should remove an entire directory",function(){
 
-tap.test('SmartFile -> should get stream', async () => {
-  const smartFile = factory.fromString('./test.txt', 'stream content');
-  const stream = smartFile.getStream();
-  expect(stream).toHaveProperty('pipe');
+            });
+            it("should remove single files",function(){
 
-  // Read from stream
-  const chunks: Buffer[] = [];
-  stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-
-  await new Promise((resolve) => {
-    stream.on('end', resolve);
+            });
+        });
     });
 
-  const content = Buffer.concat(chunks).toString();
-  expect(content).toEqual('stream content');
-});
+    describe(".interpreter",function(){
+        describe(".filetype()",function(){
+            it("should get the file type from a string",function(){
+                smartfile.interpreter.filetype("./somefolder/data.json").should.equal("json");
+            });
+        });
+    });
 
-tap.test('SmartFile -> should get size', async () => {
-  const content = 'test content with some length';
-  const smartFile = factory.fromString('./test.txt', content);
-  const size = await smartFile.getSize();
-  expect(size).toEqual(Buffer.from(content).length);
-});
 
-tap.test('SmartFile -> should parse content as buffer', async () => {
-  const buffer = Buffer.from('buffer content');
-  const smartFile = factory.fromBuffer('./test.txt', buffer);
-  const parsedBuffer = smartFile.parseContentAsBuffer();
-  expect(parsedBuffer).toBeInstanceOf(Buffer);
-  expect(parsedBuffer.toString()).toEqual('buffer content');
-});
+    describe(".fs".yellow,function(){
+        describe("toGulpStreamSync() and toGulpDestSync",function(){
+            it("should produce a gulp stream",function(done){
+                smartfile.fs.toGulpStreamSync("./test/my*")
+                    .pipe(smartfile.fs.toGulpDestSync("./test/temp/"))
+                    .pipe(gFunction(done,"atEnd"));
+            });
+        });
+        describe(".toObjectSync()".yellow,function(){
+            it("should read an " + ".yaml".blue + " file to an object",function(){
+                let testData = smartfile.fs.toObjectSync("./test/mytest.yaml");
+                testData.should.have.property("key1","this works");
+                testData.should.have.property("key2","this works too");
 
-tap.test('SmartFile -> should write to directory', async () => {
-  const smartFile = factory.fromString('subdir/test.txt', 'directory test content');
-  const writtenPath = await smartFile.writeToDir('./test/testassets/temp');
-  expect(writtenPath).toContain('subdir/test.txt');
-});
+            });
+            it("should state unknown file type for unknown file types",function(){
+                let testData = smartfile.fs.toObjectSync("./test/mytest.txt");
+            });
+            it("should read an " + ".json".blue + " file to an object",function(){
+                let testData = smartfile.fs.toObjectSync("./test/mytest.json");
+                testData.should.have.property("key1","this works");
+                testData.should.have.property("key2","this works too");
 
-tap.test('SmartFile -> should get parsed path', async () => {
-  const smartFile = factory.fromString('./path/to/file.txt', 'content');
-  expect(smartFile.parsedPath.base).toEqual('file.txt');
-  expect(smartFile.parsedPath.ext).toEqual('.txt');
-  expect(smartFile.parsedPath.name).toEqual('file');
-});
+            });
+        });
+        describe(".toStringSync()".yellow,function(){
+            it("should read a file to a string",function(){
+                should.equal(
+                    smartfile.fs.toStringSync("./test/mytest.txt"),
+                    "Some TestString &&%$"
+                );
+            });
+        });
+        describe(".toVinylSync".yellow,function(){
+            it("should read an " + ".json OR .yaml".blue + " file to an " + "vinyl file object".cyan,function(){
+                let testData = smartfile.fs.toVinylSync("./test/mytest.json");
+                (vinyl.isVinyl(testData)).should.be.true();
 
-tap.test('SmartFile -> should get absolute path', async () => {
-  const smartFile = factory.fromString('relative/path.txt', 'content', 'utf8', '/base');
-  expect(smartFile.absolutePath).toEqual('/base/relative/path.txt');
-});
+            });
+        });
+    });
 
-tap.start();
+    describe(".memory",function(){
+        describe(".toGulpStream()",function(){
+            it("should produce a valid gulp stream",function(){
+                let localArray = ["test1","test2","test3"];
+                smartfile.memory.toGulpStream(localArray)
+                    .pipe(gulp.dest("./test/temp/"));
+            });
+        });
+        describe("toVinylFileSync()",function(){
+            it("should produce a vinylFile",function(){
+                let localString = "myString";
+                let localOptions = {filename:"vinylfile2",base:"/someDir"};
+                (smartfile.memory.toVinylFileSync(localString,localOptions) instanceof vinyl).should.be.true();
+            });
+        });
+        describe("toVinylArraySync()",function(){
+            it("should produce a an array of vinylfiles",function(){
+                let localStringArray = ["string1","string2","string3"];
+                let localOptions = {filename:"vinylfile2",base:"/someDir"};
+                let testResult = smartfile.memory.toVinylArraySync(localStringArray,localOptions);
+                testResult.should.be.Array();
+                (testResult.length === 3).should.be.true();
+                for (let myKey in testResult){
+                    (testResult[myKey] instanceof vinyl).should.be.true();
+                }
+            });
+        });
+        describe("toStringSync()",function(){
+            it("should produce a String from vinyl file",function(){
+                let localString = smartfile.memory.toStringSync(new vinyl({
+                    base:"/",
+                    path:"/test.txt",
+                    contents: new Buffer("myString")
+                }));
+                localString.should.equal("myString");
+            });
+        });
+        describe("toFs()",function(){
+            it("should write a file to disk and return a promise",function(done){
+                let localString = "myString";
+                smartfile.memory.toFs(
+                    localString,
+                    path.join(process.cwd(),"./test/temp/testMemToFs.txt")
+                ).then(done);
+            });
+        });
+        describe("toFsSync()",function(){
+            it("should write a file to disk and return true if successfull",function(){
+                let localString = "myString";
+                smartfile.memory.toFsSync(
+                    localString,
+                    path.join(process.cwd(),"./test/temp/testMemToFsSync.txt")
+                );
+            });
+        });
+    });
+
+    describe(".remote",function(){
+        describe("toGulpStreamSync()",function(){
+            it("should produce a gulp stream",function(done){
+                smartfile.remote.toGulpStreamSync("mytest.txt","https://raw.githubusercontent.com/pushrocks/smartfile/master/test/")
+                    .pipe(smartfile.fs.toGulpDestSync("./test/temp/"))
+                    .pipe(gFunction(done,"atEnd"));
+            });
+        });
+        describe(".toString()",function(){
+            it("should load a remote file to a variable",function(done){
+                this.timeout(5000);
+                smartfile.remote.toString("https://raw.githubusercontent.com/pushrocks/smartfile/master/test/mytest.txt")
+                    .then(function(responseString){
+                        should.equal(responseString,"Some TestString &&%$");
+                        done();
+                    });
+            });
+            it("should reject a Promise when the link is false",function(done){
+                this.timeout(10000);
+                smartfile.remote.toString("https://push.rocks/doesnotexist.txt")
+                    .then(function(){
+                        throw new Error("this test should not be resolved");
+                    },function(){
+                        done();
+                    })
+            });
+        });
+    })
+});

test/test.virtualdirectory.ts

@@ -1,235 +0,0 @@
-import { tap, expect } from '@git.zone/tstest/tapbundle';
-import * as smartfile from '../ts/index.js';
-import { MockSmartFs } from './helpers/mock-smartfs.js';
-
-// Create factory with MockSmartFs
-const mockFs = new MockSmartFs();
-const factory = new smartfile.SmartFileFactory(mockFs);
-
-// ---------------------------
-// VirtualDirectory Factory Tests
-// ---------------------------
-
-tap.test('SmartFileFactory.virtualDirectoryFromPath() -> should create a VirtualDirectory from fs path', async () => {
-  const virtualDir = await factory.virtualDirectoryFromPath('./test/testassets/testfolder');
-  expect(virtualDir).toBeInstanceOf(smartfile.VirtualDirectory);
-  expect(virtualDir.smartfileArray.length).toEqual(4);
-});
-
-tap.test('SmartFileFactory.virtualDirectoryEmpty() -> should create an empty VirtualDirectory', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  expect(virtualDir).toBeInstanceOf(smartfile.VirtualDirectory);
-  expect(virtualDir.isEmpty()).toBeTrue();
-  expect(virtualDir.size()).toEqual(0);
-});
-
-tap.test('SmartFileFactory.virtualDirectoryFromFileArray() -> should create VirtualDirectory from files', async () => {
-  const file1 = factory.fromString('file1.txt', 'content1');
-  const file2 = factory.fromString('file2.txt', 'content2');
-
-  const virtualDir = factory.virtualDirectoryFromFileArray([file1, file2]);
-  expect(virtualDir).toBeInstanceOf(smartfile.VirtualDirectory);
-  expect(virtualDir.size()).toEqual(2);
-});
-
-// ---------------------------
-// VirtualDirectory Collection Methods
-// ---------------------------
-
-tap.test('VirtualDirectory -> should add and list files', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  const file1 = factory.fromString('test1.txt', 'content1');
-  const file2 = factory.fromString('test2.txt', 'content2');
-
-  virtualDir.addSmartfile(file1);
-  virtualDir.addSmartfile(file2);
-
-  const files = virtualDir.listFiles();
-  expect(files.length).toEqual(2);
-  expect(files[0].path).toEqual('test1.txt');
-  expect(files[1].path).toEqual('test2.txt');
-});
-
-tap.test('VirtualDirectory -> should check file existence', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  const file = factory.fromString('exists.txt', 'content');
-  virtualDir.addSmartfile(file);
-
-  expect(virtualDir.exists('exists.txt')).toBeTrue();
-  expect(virtualDir.has('exists.txt')).toBeTrue();
-  expect(virtualDir.exists('not-there.txt')).toBeFalse();
-});
-
-tap.test('VirtualDirectory -> should get file by path', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  const file = factory.fromString('getme.txt', 'my content');
-  virtualDir.addSmartfile(file);
-
-  const retrieved = await virtualDir.getFileByPath('getme.txt');
-  expect(retrieved).not.toBeUndefined();
-  expect(retrieved!.parseContentAsString()).toEqual('my content');
-});
-
-tap.test('VirtualDirectory -> should remove file by path', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  const file = factory.fromString('remove.txt', 'content');
-  virtualDir.addSmartfile(file);
-
-  expect(virtualDir.exists('remove.txt')).toBeTrue();
-
-  const removed = virtualDir.removeByPath('remove.txt');
-  expect(removed).toBeTrue();
-  expect(virtualDir.exists('remove.txt')).toBeFalse();
-});
-
-tap.test('VirtualDirectory -> should clear all files', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('file1.txt', 'content1'));
-  virtualDir.addSmartfile(factory.fromString('file2.txt', 'content2'));
-
-  expect(virtualDir.size()).toEqual(2);
-
-  virtualDir.clear();
-
-  expect(virtualDir.size()).toEqual(0);
-  expect(virtualDir.isEmpty()).toBeTrue();
-});
-
-tap.test('VirtualDirectory -> should merge with another VirtualDirectory', async () => {
-  const vdir1 = factory.virtualDirectoryEmpty();
-  vdir1.addSmartfile(factory.fromString('file1.txt', 'content1'));
-
-  const vdir2 = factory.virtualDirectoryEmpty();
-  vdir2.addSmartfile(factory.fromString('file2.txt', 'content2'));
-
-  vdir1.merge(vdir2);
-
-  expect(vdir1.size()).toEqual(2);
-  expect(vdir1.exists('file1.txt')).toBeTrue();
-  expect(vdir1.exists('file2.txt')).toBeTrue();
-});
-
-tap.test('VirtualDirectory -> should filter files', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('file1.txt', 'content1'));
-  virtualDir.addSmartfile(factory.fromString('file2.md', 'content2'));
-  virtualDir.addSmartfile(factory.fromString('file3.txt', 'content3'));
-
-  const filtered = virtualDir.filter(file => file.path.endsWith('.txt'));
-
-  expect(filtered.size()).toEqual(2);
-  expect(filtered.exists('file1.txt')).toBeTrue();
-  expect(filtered.exists('file3.txt')).toBeTrue();
-  expect(filtered.exists('file2.md')).toBeFalse();
-});
-
-tap.test('VirtualDirectory -> should map files', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('file1.txt', 'content1'));
-  virtualDir.addSmartfile(factory.fromString('file2.txt', 'content2'));
-
-  const mapped = virtualDir.map(file => {
-    file.setContentsFromString(file.parseContentAsString().toUpperCase());
-    return file;
-  });
-
-  const files = mapped.listFiles();
-  expect(files[0].parseContentAsString()).toEqual('CONTENT1');
-  expect(files[1].parseContentAsString()).toEqual('CONTENT2');
-});
-
-tap.test('VirtualDirectory -> should find files', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('find.txt', 'findme'));
-  virtualDir.addSmartfile(factory.fromString('other.txt', 'other'));
-
-  const found = virtualDir.find(file => file.parseContentAsString() === 'findme');
-
-  expect(found).not.toBeUndefined();
-  expect(found!.path).toEqual('find.txt');
-});
-
-tap.test('VirtualDirectory -> should list directories', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('dir1/file1.txt', 'content1'));
-  virtualDir.addSmartfile(factory.fromString('dir1/file2.txt', 'content2'));
-  virtualDir.addSmartfile(factory.fromString('dir2/file3.txt', 'content3'));
-  virtualDir.addSmartfile(factory.fromString('root.txt', 'content4'));
-
-  const dirs = virtualDir.listDirectories();
-
-  expect(dirs).toContain('dir1');
-  expect(dirs).toContain('dir2');
-  expect(dirs.length).toEqual(2);
-});
-
-tap.test('VirtualDirectory -> should save to disk', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('saved1.txt', 'saved content 1'));
-  virtualDir.addSmartfile(factory.fromString('subdir/saved2.txt', 'saved content 2'));
-
-  await virtualDir.saveToDisk('./test/testassets/temp/vdir-output');
-
-  // Verify files were written
-  const file1 = await factory.fromFilePath('./test/testassets/temp/vdir-output/saved1.txt');
-  expect(file1.parseContentAsString()).toEqual('saved content 1');
-
-  const file2 = await factory.fromFilePath('./test/testassets/temp/vdir-output/subdir/saved2.txt');
-  expect(file2.parseContentAsString()).toEqual('saved content 2');
-});
-
-tap.test('VirtualDirectory -> should convert to transferable object', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('trans1.txt', 'transferable1'));
-  virtualDir.addSmartfile(factory.fromString('trans2.txt', 'transferable2'));
-
-  const transferable = await virtualDir.toVirtualDirTransferableObject();
-
-  expect(transferable.files).toBeInstanceOf(Array);
-  expect(transferable.files.length).toEqual(2);
-});
-
-// TODO: Fix serialization/deserialization with smartjson
-// tap.test('VirtualDirectory -> should create from transferable object', async () => {
-//   const originalDir = factory.virtualDirectoryEmpty();
-//   originalDir.addSmartfile(factory.fromString('original.txt', 'original content'));
-
-//   const transferable = await originalDir.toVirtualDirTransferableObject();
-//   const restoredDir = await factory.virtualDirectoryFromTransferable(transferable);
-
-//   expect(restoredDir.size()).toEqual(1);
-//   expect(restoredDir.exists('original.txt')).toBeTrue();
-
-//   const file = await restoredDir.getFileByPath('original.txt');
-//   expect(file!.parseContentAsString()).toEqual('original content');
-// });
-
-tap.test('VirtualDirectory -> should shift to subdirectory', async () => {
-  const virtualDir = factory.virtualDirectoryEmpty();
-  virtualDir.addSmartfile(factory.fromString('root/sub/file1.txt', 'content1'));
-  virtualDir.addSmartfile(factory.fromString('root/sub/file2.txt', 'content2'));
-  virtualDir.addSmartfile(factory.fromString('root/other.txt', 'content3'));
-
-  const shifted = await virtualDir.shiftToSubdirectory('root/sub');
-
-  expect(shifted.size()).toEqual(2);
-  expect(shifted.exists('file1.txt')).toBeTrue();
-  expect(shifted.exists('file2.txt')).toBeTrue();
-  expect(shifted.exists('other.txt')).toBeFalse();
-});
-
-tap.test('VirtualDirectory -> should add another virtual directory with new root', async () => {
-  const vdir1 = factory.virtualDirectoryEmpty();
-  vdir1.addSmartfile(factory.fromString('existing.txt', 'existing'));
-
-  const vdir2 = factory.virtualDirectoryEmpty();
-  vdir2.addSmartfile(factory.fromString('added.txt', 'added'));
-
-  await vdir1.addVirtualDirectory(vdir2, 'newroot');
-
-  expect(vdir1.size()).toEqual(2);
-  expect(vdir1.exists('existing.txt')).toBeTrue();
-  expect(vdir1.exists('newroot/added.txt')).toBeTrue();
-});
-
-tap.start();

test/testassets/temp/mytest-fromdir.json

@@ -1,7 +0,0 @@
-{
-  "key1": "this works",
-  "key2": "this works too",
-  "key3": {
-    "nestedkey1": "hello"
-  }
-}

test/testassets/temp/mytest.json

@@ -1,7 +0,0 @@
-{
-  "key1": "this works",
-  "key2": "this works too",
-  "key3": {
-    "nestedkey1": "hello"
-  }
-}

test/testassets/temp/mytest.yaml

@@ -1,4 +0,0 @@
-key1: this works
-key2: this works too
-key3:
-  nestedkey1: hello

test/testassets/temp/stream-mytest.json

@@ -1,7 +0,0 @@
-{
-  "key1": "this works",
-  "key2": "this works too",
-  "key3": {
-    "nestedkey1": "hello"
-  }
-}

test/testassets/temp/subdir/test.txt

@@ -1 +0,0 @@
-directory test content

test/testassets/temp/subfolder/deepsubfolder/deepsubtestfile.txt

@@ -1 +0,0 @@
-okidoks

test/testassets/temp/subfolder/subtestfile.txt

@@ -1 +0,0 @@
-hi

test/testassets/temp/test/testassets/mytest.json

@@ -1,7 +0,0 @@
-{
-  "key1": "this works",
-  "key2": "this works too",
-  "key3": {
-    "nestedkey1": "hello"
-  }
-}

test/testassets/temp/testMemToFs.txt

@@ -1 +0,0 @@
-myString

test/testassets/temp/testMemToFsSync.txt

@@ -1 +0,0 @@
-myString

test/testassets/temp/utf8.txt

@@ -1 +0,0 @@
-hi there

test/testassets/temp/vdir-output/saved1.txt

@@ -1 +0,0 @@
-saved content 1

test/testassets/temp/vdir-output/subdir/saved2.txt

@@ -1 +0,0 @@
-saved content 2

test/testassets/test/subfolder/deepsubfolder/deepsubtestfile.txt

@@ -1 +0,0 @@
-okidoks

test/testassets/test/subfolder/subtestfile.txt

@@ -1 +0,0 @@
-hi

test/testassets/testfolder/subfolder/deepsubfolder/deepsubtestfile.txt

@@ -1 +0,0 @@
-okidoks

test/testassets/testfolder/subfolder/subtestfile.txt

@@ -1 +0,0 @@
-hi

test/testassets/utf8.txt

@@ -1 +0,0 @@
-hi there

ts/00_commitinfo_data.ts

@@ -1,8 +0,0 @@
-/**
- * autocreated commitinfo by @push.rocks/commitinfo
- */
-export const commitinfo = {
-  name: '@push.rocks/smartfile',
-  version: '13.0.1',
-  description: 'High-level file representation classes (SmartFile, StreamFile, VirtualDirectory) for efficient in-memory file management in Node.js using TypeScript. Works seamlessly with @push.rocks/smartfs for filesystem operations.'
-}

ts/classes.smartfile.factory.ts

@@ -1,224 +0,0 @@
-import * as plugins from './plugins.js';
-import { SmartFile } from './classes.smartfile.js';
-import { StreamFile } from './classes.streamfile.js';
-import { VirtualDirectory } from './classes.virtualdirectory.js';
-
-export class SmartFileFactory {
-  private smartFs: any; // Will be typed as SmartFs once we import from @push.rocks/smartfs
-
-  constructor(smartFs: any) {
-    this.smartFs = smartFs;
-  }
-
-  /**
-   * Creates a default factory using Node.js filesystem provider
-   */
-  public static nodeFs(): SmartFileFactory {
-    // Temporarily using a placeholder - will be replaced with actual SmartFs initialization
-    // const smartFs = new SmartFs(new SmartFsProviderNode());
-    const smartFs = null; // Placeholder
-    return new SmartFileFactory(smartFs);
-  }
-
-  /**
-   * Get the underlying SmartFs instance
-   */
-  public getSmartFs(): any {
-    return this.smartFs;
-  }
-
-  // ============================================
-  // SmartFile Factory Methods
-  // ============================================
-
-  /**
-   * Creates a SmartFile from a file path on disk
-   */
-  public async fromFilePath(
-    filePath: string,
-    baseArg: string = process.cwd()
-  ): Promise<SmartFile> {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Cannot read from filesystem without SmartFs.');
-    }
-
-    filePath = plugins.path.resolve(filePath);
-    const content = await this.smartFs.file(filePath).read();
-    const fileBuffer = Buffer.from(content);
-
-    return new SmartFile({
-      contentBuffer: fileBuffer,
-      base: baseArg,
-      path: plugins.path.relative(baseArg, filePath),
-    }, this.smartFs);
-  }
-
-  /**
-   * Creates a SmartFile from a URL
-   */
-  public async fromUrl(urlArg: string): Promise<SmartFile> {
-    const response = await plugins.smartrequest.SmartRequest.create()
-      .url(urlArg)
-      .accept('binary')
-      .get();
-    const buffer = Buffer.from(await response.arrayBuffer());
-
-    return new SmartFile({
-      contentBuffer: buffer,
-      base: process.cwd(),
-      path: urlArg,
-    }, this.smartFs);
-  }
-
-  /**
-   * Creates a SmartFile from a Buffer
-   */
-  public fromBuffer(
-    filePath: string,
-    contentBufferArg: Buffer,
-    baseArg: string = process.cwd()
-  ): SmartFile {
-    // Use filePath as-is if it's already relative, otherwise compute relative path
-    const relativePath = plugins.path.isAbsolute(filePath)
-      ? plugins.path.relative(baseArg, filePath)
-      : filePath;
-
-    return new SmartFile({
-      contentBuffer: contentBufferArg,
-      base: baseArg,
-      path: relativePath,
-    }, this.smartFs);
-  }
-
-  /**
-   * Creates a SmartFile from a string
-   */
-  public fromString(
-    filePath: string,
-    contentStringArg: string,
-    encodingArg: 'utf8' | 'binary' = 'utf8',
-    baseArg: string = process.cwd()
-  ): SmartFile {
-    // Use filePath as-is if it's already relative, otherwise compute relative path
-    const relativePath = plugins.path.isAbsolute(filePath)
-      ? plugins.path.relative(baseArg, filePath)
-      : filePath;
-
-    return new SmartFile({
-      contentBuffer: Buffer.from(contentStringArg, encodingArg),
-      base: baseArg,
-      path: relativePath,
-    }, this.smartFs);
-  }
-
-  /**
-   * Creates a SmartFile from a stream
-   */
-  public async fromStream(
-    stream: plugins.stream.Readable,
-    filePath: string,
-    baseArg: string = process.cwd()
-  ): Promise<SmartFile> {
-    return new Promise<SmartFile>((resolve, reject) => {
-      const chunks: Buffer[] = [];
-      stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-      stream.on('error', (error) => reject(error));
-      stream.on('end', () => {
-        const contentBuffer = Buffer.concat(chunks);
-        const smartfile = new SmartFile({
-          contentBuffer: contentBuffer,
-          base: baseArg,
-          path: plugins.path.relative(baseArg, filePath),
-        }, this.smartFs);
-        resolve(smartfile);
-      });
-    });
-  }
-
-  /**
-   * Creates a SmartFile from folded JSON
-   */
-  public async fromFoldedJson(foldedJsonArg: string): Promise<SmartFile> {
-    const parsed = plugins.smartjson.parse(foldedJsonArg);
-    return new SmartFile(parsed, this.smartFs);
-  }
-
-  // ============================================
-  // StreamFile Factory Methods
-  // ============================================
-
-  /**
-   * Creates a StreamFile from a file path
-   */
-  public async streamFromPath(filePath: string): Promise<StreamFile> {
-    return StreamFile.fromPath(filePath, this.smartFs);
-  }
-
-  /**
-   * Creates a StreamFile from a URL
-   */
-  public async streamFromUrl(url: string): Promise<StreamFile> {
-    return StreamFile.fromUrl(url, this.smartFs);
-  }
-
-  /**
-   * Creates a StreamFile from a Buffer
-   */
-  public streamFromBuffer(buffer: Buffer, relativeFilePath?: string): StreamFile {
-    return StreamFile.fromBuffer(buffer, relativeFilePath, this.smartFs);
-  }
-
-  /**
-   * Creates a StreamFile from a Node.js Readable stream
-   */
-  public streamFromStream(
-    stream: plugins.stream.Readable,
-    relativeFilePath?: string,
-    multiUse: boolean = false
-  ): StreamFile {
-    return StreamFile.fromStream(stream, relativeFilePath, multiUse, this.smartFs);
-  }
-
-  // ============================================
-  // VirtualDirectory Factory Methods
-  // ============================================
-
-  /**
-   * Creates a VirtualDirectory from a filesystem directory path
-   */
-  public async virtualDirectoryFromPath(pathArg: string): Promise<VirtualDirectory> {
-    return VirtualDirectory.fromFsDirPath(pathArg, this.smartFs, this);
-  }
-
-  /**
-   * Creates an empty VirtualDirectory
-   */
-  public virtualDirectoryEmpty(): VirtualDirectory {
-    return new VirtualDirectory(this.smartFs, this);
-  }
-
-  /**
-   * Creates a VirtualDirectory from an array of SmartFiles
-   */
-  public virtualDirectoryFromFileArray(files: SmartFile[]): VirtualDirectory {
-    const vdir = new VirtualDirectory(this.smartFs, this);
-    vdir.addSmartfiles(files);
-    return vdir;
-  }
-
-  /**
-   * Creates a VirtualDirectory from a transferable object
-   */
-  public async virtualDirectoryFromTransferable(
-    virtualDirTransferableObjectArg: plugins.smartfileInterfaces.VirtualDirTransferableObject
-  ): Promise<VirtualDirectory> {
-    const newVirtualDir = new VirtualDirectory(this.smartFs, this);
-    for (const fileArg of virtualDirTransferableObjectArg.files) {
-      const smartFile = SmartFile.enfoldFromJson(fileArg) as SmartFile;
-      // Update the smartFs reference
-      (smartFile as any).smartFs = this.smartFs;
-      newVirtualDir.addSmartfiles([smartFile]);
-    }
-    return newVirtualDir;
-  }
-}

ts/classes.smartfile.ts

@@ -1,334 +0,0 @@
-import * as plugins from './plugins.js';
-
-export interface ISmartfileConstructorOptions {
-  path: string;
-  contentBuffer: Buffer;
-  base: string;
-}
-
-/**
- * an vinyl file compatible in memory file class
- * Use SmartFileFactory to create instances of this class
- */
-export class SmartFile extends plugins.smartjson.Smartjson {
-  // ========
-  // INSTANCE
-  // ========
-
-  /**
-   * Reference to the SmartFs instance for filesystem operations
-   */
-  private smartFs?: any;
-  /**
-   * the relative path of the file
-   */
-  @plugins.smartjson.foldDec()
-  public path: string;
-
-  /**
-   * a parsed path
-   */
-  public get parsedPath(): plugins.path.ParsedPath {
-    return plugins.path.parse(this.path);
-  }
-  public get absolutePath() {
-    return plugins.path.join(this.base, this.path);
-  }
-
-  public get absoluteParsedPath() {
-    return plugins.path.parse(this.absolutePath);
-  }
-
-  /**
-   * the content of the file as Buffer
-   */
-  @plugins.smartjson.foldDec()
-  public contentBuffer: Buffer;
-
-  /**
-   * The current working directory of the file
-   * Note:this is similar to gulp and different from native node path base
-   */
-  @plugins.smartjson.foldDec()
-  public base: string;
-
-  /**
-   * sync the file with disk
-   */
-  @plugins.smartjson.foldDec()
-  public sync: boolean;
-
-  /**
-   * the constructor of Smartfile
-   * @param optionsArg
-   * @param smartFs optional SmartFs instance for filesystem operations
-   */
-
-  constructor(optionsArg: ISmartfileConstructorOptions, smartFs?: any) {
-    super();
-    if (optionsArg.contentBuffer) {
-      this.contentBuffer = optionsArg.contentBuffer;
-    } else {
-      console.log('created empty Smartfile?');
-    }
-    this.path = optionsArg.path;
-    this.base = optionsArg.base;
-    this.smartFs = smartFs;
-  }
-
-  /**
-   * set contents from string
-   * @param contentString
-   */
-  public setContentsFromString(
-    contentString: string,
-    encodingArg: 'utf8' | 'binary' = 'utf8',
-  ) {
-    this.contents = Buffer.from(contentString, encodingArg);
-  }
-
-  /**
-   * write file to disk at its original location
-   * Behaviours:
-   * - no argument write to exactly where the file was picked up
-   * - Requires SmartFs instance (create via SmartFileFactory)
-   */
-  public async write() {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Create SmartFile through SmartFileFactory.');
-    }
-
-    const writePath = plugins.smartpath.transform.makeAbsolute(
-      this.path,
-      this.base,
-    );
-    console.log(`writing to ${writePath}`);
-    await this.smartFs.file(writePath).write(this.contentBuffer);
-  }
-
-  /**
-   * writes the file to path given as argument
-   * note: if the path is not absolute, takes process.cwd() as base
-   * @param filePathArg
-   */
-  public async writeToDiskAtPath(filePathArg: string) {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Create SmartFile through SmartFileFactory.');
-    }
-
-    if (!plugins.path.isAbsolute(filePathArg)) {
-      filePathArg = plugins.path.join(process.cwd(), filePathArg);
-    }
-
-    await this.smartFs.file(filePathArg).write(this.contentBuffer);
-  }
-
-  /**
-   * writes the file to a directory combined with the relative path portion
-   * @param dirPathArg
-   * @returns
-   */
-  public async writeToDir(dirPathArg: string) {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Create SmartFile through SmartFileFactory.');
-    }
-
-    dirPathArg = plugins.smartpath.transform.toAbsolute(dirPathArg) as string;
-    const filePath = plugins.path.join(dirPathArg, this.path);
-    await this.smartFs.file(filePath).write(this.contentBuffer);
-    return filePath;
-  }
-
-  /**
-   * read file from disk
-   */
-  public async read() {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Create SmartFile through SmartFileFactory.');
-    }
-
-    const filePath = plugins.path.join(this.base, this.path);
-    const content = await this.smartFs.file(filePath).read();
-    this.contentBuffer = Buffer.from(content);
-  }
-
-  /**
-   * deletes the file from disk at its original location
-   */
-  public async delete() {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Create SmartFile through SmartFileFactory.');
-    }
-
-    const filePath = plugins.path.join(this.base, this.path);
-    await this.smartFs.file(filePath).delete();
-  }
-
-  /**
-   * Renames the file to the specified new name.
-   * - Updates the `path` property with the new name.
-   * - Writes the file to the new location if it exists on disk.
-   * @param newName The new name of the file (including extension if applicable).
-   * @param writeToDisk (optional) If true, also renames the file on the disk.
-   * @returns The updated file path after renaming.
-   */
-  public async rename(
-    newName: string,
-    writeToDisk: boolean = false,
-  ): Promise<string> {
-    // Validate the new name
-    if (!newName || typeof newName !== 'string') {
-      throw new Error('Invalid new name provided.');
-    }
-
-    // Extract the directory path
-    const oldFilePath = this.path;
-    const dirPath = plugins.path.dirname(this.path);
-
-    // Create the new file path
-    const newFilePath = plugins.path.join(dirPath, newName);
-
-    // Update the `path` property
-    this.path = newFilePath;
-
-    // Optionally write the renamed file to disk
-    if (writeToDisk) {
-      const oldAbsolutePath = plugins.smartpath.transform.makeAbsolute(
-        oldFilePath,
-        this.base,
-      );
-      const newAbsolutePath = plugins.smartpath.transform.makeAbsolute(
-        newFilePath,
-        this.base,
-      );
-
-      // Rename the file on disk
-      await plugins.fsPromises.rename(oldAbsolutePath, newAbsolutePath);
-    }
-
-    // Return the new path
-    return this.path;
-  }
-
-  // -----------------------------------------------
-  // vinyl compatibility
-  // -----------------------------------------------
-  /**
-   * vinyl-compatibility: alias of this.contentBuffer
-   */
-  get contents(): Buffer {
-    return this.contentBuffer;
-  }
-  set contents(contentsArg) {
-    this.contentBuffer = contentsArg;
-  }
-
-  /**
-   * vinyl-compatibility
-   */
-  public get cwd() {
-    return process.cwd();
-  }
-
-  /**
-   * return relative path of file
-   */
-  public get relative(): string {
-    return this.path;
-  }
-
-  /**
-   * return truw when the file has content
-   */
-  public isNull(): boolean {
-    if (!this.contentBuffer) {
-      return true;
-    }
-    return false;
-  }
-
-  /**
-   * return true if contents are Buffer
-   */
-  public isBuffer(): boolean {
-    if (this.contents instanceof Buffer) {
-      return true;
-    }
-    return false;
-  }
-
-  public isDirectory() {
-    return false;
-  }
-
-  public isStream() {
-    return false;
-  }
-
-  public isSymbolic() {
-    return false;
-  }
-
-  public async getHash(typeArg: 'path' | 'content' | 'all' = 'all') {
-    const pathHash = await plugins.smarthash.sha256FromString(this.path);
-    const contentHash = await plugins.smarthash.sha256FromBuffer(
-      this.contentBuffer,
-    );
-    const combinedHash = await plugins.smarthash.sha256FromString(
-      pathHash + contentHash,
-    );
-    switch (typeArg) {
-      case 'path':
-        return pathHash;
-      case 'content':
-        return contentHash;
-      case 'all':
-      default:
-        return combinedHash;
-    }
-  }
-
-  // update things
-  public updateFileName(fileNameArg: string) {
-    const oldFileName = this.parsedPath.base;
-    this.path = this.path.replace(new RegExp(oldFileName + '$'), fileNameArg);
-  }
-
-  public async editContentAsString(
-    editFuncArg: (fileStringArg: string) => Promise<string>,
-  ) {
-    const newFileString = await editFuncArg(this.contentBuffer.toString());
-    this.contentBuffer = Buffer.from(newFileString);
-  }
-
-  /**
-   * Returns a ReadableStream from the file's content buffer
-   */
-  public getStream(): plugins.stream.Readable {
-    const stream = new plugins.stream.Readable();
-    stream.push(this.contentBuffer); // Push the content buffer to the stream
-    stream.push(null); // Push null to signify the end of the stream (EOF)
-    return stream;
-  }
-
-  /**
-   * Returns the size of the file in bytes
-   */
-  public async getSize(): Promise<number> {
-    return this.contentBuffer.length;
-  }
-
-  /**
-   * Parse content as string with specified encoding
-   */
-  public parseContentAsString(encodingArg: BufferEncoding = 'utf8'): string {
-    return this.contentBuffer.toString(encodingArg);
-  }
-
-  /**
-   * Parse content as buffer
-   */
-  public parseContentAsBuffer(): Buffer {
-    return this.contentBuffer;
-  }
-}

ts/classes.streamfile.ts

@@ -1,236 +0,0 @@
-import * as plugins from './plugins.js';
-import { Readable, Writable } from 'stream';
-
-type TStreamSource = (streamFile: StreamFile) => Promise<Readable | ReadableStream>;
-
-/**
- * The StreamFile class represents a file as a stream.
- * It allows creating streams from a file path, a URL, or a buffer.
- * Use SmartFileFactory to create instances of this class.
- */
-export class StreamFile {
-  // STATIC
-
-  public static async fromPath(filePath: string, smartFs?: any): Promise<StreamFile> {
-    if (!smartFs) {
-      throw new Error('No SmartFs instance available. Create StreamFile through SmartFileFactory.');
-    }
-
-    const streamSource: TStreamSource = async (streamFileArg) => {
-      return await streamFileArg.smartFs.file(filePath).readStream();
-    };
-    const streamFile = new StreamFile(streamSource, filePath, smartFs);
-    streamFile.multiUse = true;
-    streamFile.byteLengthComputeFunction = async () => {
-      const stats = await smartFs.file(filePath).stat();
-      return stats.size;
-    };
-    return streamFile;
-  }
-
-  public static async fromUrl(url: string, smartFs?: any): Promise<StreamFile> {
-    const streamSource: TStreamSource = async (streamFileArg) => {
-      const response = await plugins.smartrequest.SmartRequest.create()
-        .url(url)
-        .get();
-      return response.stream();
-    };
-    const streamFile = new StreamFile(streamSource, undefined, smartFs);
-    streamFile.multiUse = true;
-    streamFile.byteLengthComputeFunction = async () => {
-      const response = await plugins.smartrequest.SmartRequest.create()
-        .url(url)
-        .accept('binary')
-        .get();
-      const buffer = Buffer.from(await response.arrayBuffer());
-      return buffer.length;
-    };
-    return streamFile;
-  }
-
-  public static fromBuffer(
-    buffer: Buffer,
-    relativeFilePath?: string,
-    smartFs?: any
-  ): StreamFile {
-    const streamSource: TStreamSource = async (streamFileArg) => {
-      const stream = new Readable();
-      stream.push(buffer);
-      stream.push(null); // End of stream
-      return stream;
-    };
-    const streamFile = new StreamFile(streamSource, relativeFilePath, smartFs);
-    streamFile.multiUse = true;
-    streamFile.byteLengthComputeFunction = async () => buffer.length;
-    return streamFile;
-  }
-
-  /**
-   * Creates a StreamFile from an existing Readable stream with an option for multiple uses.
-   * @param stream A Node.js Readable stream.
-   * @param relativeFilePath Optional file path for the stream.
-   * @param multiUse If true, the stream can be read multiple times, caching its content.
-   * @param smartFs Optional SmartFs instance for filesystem operations
-   * @returns A StreamFile instance.
-   */
-  public static fromStream(
-    stream: Readable,
-    relativeFilePath?: string,
-    multiUse: boolean = false,
-    smartFs?: any
-  ): StreamFile {
-    const streamSource: TStreamSource = (streamFileArg) => {
-      if (streamFileArg.multiUse) {
-        // If multi-use is enabled and we have cached content, create a new readable stream from the buffer
-        const bufferedStream = new Readable();
-        bufferedStream.push(streamFileArg.cachedStreamBuffer);
-        bufferedStream.push(null); // No more data to push
-        return Promise.resolve(bufferedStream);
-      } else {
-        return Promise.resolve(stream);
-      }
-    };
-
-    const streamFile = new StreamFile(streamSource, relativeFilePath, smartFs);
-    streamFile.multiUse = multiUse;
-
-    // If multi-use is enabled, cache the stream when it's first read
-    if (multiUse) {
-      const chunks: Buffer[] = [];
-      stream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-      stream.on('end', () => {
-        streamFile.cachedStreamBuffer = Buffer.concat(chunks);
-      });
-      // It's important to handle errors that may occur during streaming
-      stream.on('error', (err) => {
-        console.error('Error while caching stream:', err);
-      });
-    }
-
-    return streamFile;
-  }
-
-  // INSTANCE
-  relativeFilePath?: string;
-  private streamSource: TStreamSource;
-  private smartFs?: any;
-
-  // enable stream based multi use
-  private cachedStreamBuffer?: Buffer;
-  public multiUse: boolean;
-  public used: boolean = false;
-  public byteLengthComputeFunction: () => Promise<number>;
-
-  private constructor(streamSource: TStreamSource, relativeFilePath?: string, smartFs?: any) {
-    this.streamSource = streamSource;
-    this.relativeFilePath = relativeFilePath;
-    this.smartFs = smartFs;
-  }
-
-  // METHODS
-
-  private checkMultiUse() {
-    if (!this.multiUse && this.used) {
-      throw new Error('This stream can only be used once.');
-    }
-    this.used = true;
-  }
-
-  /**
-   * Creates a new readable stream from the source.
-   */
-  public async createReadStream(): Promise<Readable> {
-    const stream = await this.streamSource(this);
-    
-    // Check if it's a Web ReadableStream and convert to Node.js Readable
-    if (stream && typeof (stream as any).getReader === 'function') {
-      // This is a Web ReadableStream, convert it to Node.js Readable
-      return Readable.fromWeb(stream as any);
-    }
-    
-    // It's already a Node.js Readable stream
-    return stream as Readable;
-  }
-
-  /**
-   * Writes the stream to the disk at the specified path.
-   * @param filePathArg The file path where the stream should be written.
-   */
-  public async writeToDisk(filePathArg: string): Promise<void> {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Create StreamFile through SmartFileFactory.');
-    }
-
-    this.checkMultiUse();
-    const readStream = await this.createReadStream();
-    let writeStream = await this.smartFs.file(filePathArg).writeStream();
-
-    // Check if it's a Web WritableStream and convert to Node.js Writable
-    if (writeStream && typeof (writeStream as any).getWriter === 'function') {
-      // This is a Web WritableStream, convert it to Node.js Writable
-      writeStream = Writable.fromWeb(writeStream as any);
-    }
-
-    return new Promise((resolve, reject) => {
-      readStream.pipe(writeStream);
-      readStream.on('error', reject);
-      writeStream.on('error', reject);
-      writeStream.on('finish', resolve);
-    });
-  }
-
-  public async writeToDir(dirPathArg: string) {
-    if (!this.smartFs) {
-      throw new Error('No SmartFs instance available. Create StreamFile through SmartFileFactory.');
-    }
-
-    this.checkMultiUse();
-    const filePath = plugins.path.join(dirPathArg, this.relativeFilePath);
-    const dirPath = plugins.path.parse(filePath).dir;
-    await this.smartFs.directory(dirPath).recursive().create();
-    return this.writeToDisk(filePath);
-  }
-
-  public async getContentAsBuffer() {
-    this.checkMultiUse();
-    const done = plugins.smartpromise.defer<Buffer>();
-    const readStream = await this.createReadStream();
-    const chunks: Buffer[] = [];
-    readStream.on('data', (chunk) => chunks.push(Buffer.from(chunk)));
-    readStream.on('error', done.reject);
-    readStream.on('end', () => {
-      const contentBuffer = Buffer.concat(chunks);
-      done.resolve(contentBuffer);
-    });
-    return done.promise;
-  }
-
-  public async getContentAsString(formatArg: 'utf8' | 'binary' = 'utf8') {
-    const contentBuffer = await this.getContentAsBuffer();
-    return contentBuffer.toString(formatArg);
-  }
-
-  /**
-   * Returns the size of the file content in bytes.
-   */
-  public async getSize(): Promise<number> {
-    if (this.byteLengthComputeFunction) {
-      return this.byteLengthComputeFunction();
-    } else {
-      return null;
-    }
-  }
-
-  /**
-   * Converts the StreamFile to a SmartFile by loading content into memory
-   */
-  public async toSmartFile(): Promise<any> {
-    const { SmartFile } = await import('./classes.smartfile.js');
-    const buffer = await this.getContentAsBuffer();
-    return new SmartFile({
-      path: this.relativeFilePath || 'stream',
-      contentBuffer: buffer,
-      base: process.cwd()
-    }, this.smartFs);
-  }
-}

ts/classes.virtualdirectory.ts

@@ -1,201 +0,0 @@
-import { SmartFile } from './classes.smartfile.js';
-import * as plugins from './plugins.js';
-
-export interface IVirtualDirectoryConstructorOptions {
-  mode: '';
-}
-
-/**
- * a virtual directory exposes a fs api
- * Use SmartFileFactory to create instances of this class
- */
-export class VirtualDirectory {
-  // STATIC
-  public static async fromFsDirPath(
-    pathArg: string,
-    smartFs?: any,
-    factory?: any
-  ): Promise<VirtualDirectory> {
-    if (!smartFs || !factory) {
-      throw new Error('No SmartFs/Factory instance available. Create VirtualDirectory through SmartFileFactory.');
-    }
-
-    const newVirtualDir = new VirtualDirectory(smartFs, factory);
-
-    // Use smartFs to list directory and factory to create SmartFiles
-    const entries = await smartFs.directory(pathArg).recursive().list();
-    const smartfiles = await Promise.all(
-      entries
-        .filter((entry: any) => entry.isFile)
-        .map((entry: any) => factory.fromFilePath(entry.path, pathArg))
-    );
-    newVirtualDir.addSmartfiles(smartfiles);
-
-    return newVirtualDir;
-  }
-
-  public static async fromVirtualDirTransferableObject(
-    virtualDirTransferableObjectArg: plugins.smartfileInterfaces.VirtualDirTransferableObject,
-    smartFs?: any,
-    factory?: any
-  ): Promise<VirtualDirectory> {
-    const newVirtualDir = new VirtualDirectory(smartFs, factory);
-    for (const fileArg of virtualDirTransferableObjectArg.files) {
-      const smartFile = SmartFile.enfoldFromJson(fileArg) as SmartFile;
-      // Update smartFs reference if available
-      if (smartFs) {
-        (smartFile as any).smartFs = smartFs;
-      }
-      newVirtualDir.addSmartfiles([smartFile]);
-    }
-    return newVirtualDir;
-  }
-
-  public static fromFileArray(files: SmartFile[], smartFs?: any, factory?: any): VirtualDirectory {
-    const vdir = new VirtualDirectory(smartFs, factory);
-    vdir.addSmartfiles(files);
-    return vdir;
-  }
-
-  public static empty(smartFs?: any, factory?: any): VirtualDirectory {
-    return new VirtualDirectory(smartFs, factory);
-  }
-
-  // INSTANCE
-  public smartfileArray: SmartFile[] = [];
-  private smartFs?: any;
-  private factory?: any;
-
-  constructor(smartFs?: any, factory?: any) {
-    this.smartFs = smartFs;
-    this.factory = factory;
-  }
-
-  // ============================================
-  // Collection Mutations
-  // ============================================
-
-  public addSmartfiles(smartfileArrayArg: SmartFile[]) {
-    this.smartfileArray = this.smartfileArray.concat(smartfileArrayArg);
-  }
-
-  public addSmartfile(smartfileArg: SmartFile): void {
-    this.smartfileArray.push(smartfileArg);
-  }
-
-  public removeByPath(pathArg: string): boolean {
-    const initialLength = this.smartfileArray.length;
-    this.smartfileArray = this.smartfileArray.filter(f => f.path !== pathArg);
-    return this.smartfileArray.length < initialLength;
-  }
-
-  public clear(): void {
-    this.smartfileArray = [];
-  }
-
-  public merge(otherVDir: VirtualDirectory): void {
-    this.addSmartfiles(otherVDir.smartfileArray);
-  }
-
-  // ============================================
-  // Collection Queries
-  // ============================================
-
-  public exists(pathArg: string): boolean {
-    return this.smartfileArray.some(f => f.path === pathArg);
-  }
-
-  public has(pathArg: string): boolean {
-    return this.exists(pathArg);
-  }
-
-  public async getFileByPath(pathArg: string): Promise<SmartFile | undefined> {
-    return this.smartfileArray.find(f => f.path === pathArg);
-  }
-
-  public listFiles(): SmartFile[] {
-    return [...this.smartfileArray];
-  }
-
-  public listDirectories(): string[] {
-    const dirs = new Set<string>();
-    for (const file of this.smartfileArray) {
-      const dir = plugins.path.dirname(file.path);
-      if (dir !== '.') {
-        dirs.add(dir);
-      }
-    }
-    return Array.from(dirs).sort();
-  }
-
-  public filter(predicate: (file: SmartFile) => boolean): VirtualDirectory {
-    const newVDir = new VirtualDirectory(this.smartFs, this.factory);
-    newVDir.addSmartfiles(this.smartfileArray.filter(predicate));
-    return newVDir;
-  }
-
-  public map(fn: (file: SmartFile) => SmartFile): VirtualDirectory {
-    const newVDir = new VirtualDirectory(this.smartFs, this.factory);
-    newVDir.addSmartfiles(this.smartfileArray.map(fn));
-    return newVDir;
-  }
-
-  public find(predicate: (file: SmartFile) => boolean): SmartFile | undefined {
-    return this.smartfileArray.find(predicate);
-  }
-
-  public size(): number {
-    return this.smartfileArray.length;
-  }
-
-  public isEmpty(): boolean {
-    return this.smartfileArray.length === 0;
-  }
-
-  public async toVirtualDirTransferableObject(): Promise<plugins.smartfileInterfaces.VirtualDirTransferableObject> {
-    return {
-      files: this.smartfileArray.map((smartfileArg) =>
-        smartfileArg.foldToJson(),
-      ),
-    };
-  }
-
-  public async saveToDisk(dirArg: string) {
-    console.log(`writing VirtualDirectory with ${this.smartfileArray.length} files to directory:
-    --> ${dirArg}`);
-    for (const smartfileArg of this.smartfileArray) {
-      const filePath = await smartfileArg.writeToDir(dirArg);
-      console.log(`wrote ${smartfileArg.relative} to
-        --> ${filePath}`);
-    }
-  }
-
-  public async shiftToSubdirectory(subDir: string): Promise<VirtualDirectory> {
-    const newVirtualDir = new VirtualDirectory(this.smartFs, this.factory);
-    for (const file of this.smartfileArray) {
-      if (file.path.startsWith(subDir)) {
-        const adjustedFilePath = plugins.path.relative(subDir, file.path);
-        file.path = adjustedFilePath;
-        newVirtualDir.addSmartfiles([file]);
-      }
-    }
-    return newVirtualDir;
-  }
-
-  public async loadFromDisk(dirArg: string): Promise<void> {
-    // Load from disk, replacing current collection
-    this.clear();
-    const loaded = await VirtualDirectory.fromFsDirPath(dirArg, this.smartFs, this.factory);
-    this.addSmartfiles(loaded.smartfileArray);
-  }
-
-  public async addVirtualDirectory(
-    virtualDir: VirtualDirectory,
-    newRoot: string,
-  ): Promise<void> {
-    for (const file of virtualDir.smartfileArray) {
-      file.path = plugins.path.join(newRoot, file.path);
-    }
-    this.addSmartfiles(virtualDir.smartfileArray);
-  }
-}

ts/index.ts

@@ -1,11 +1,15 @@
-import * as plugins from './plugins.js';
+import "typings-global";
 
-// Export main classes - focused on in-memory file representations
-export * from './classes.smartfile.js';
-export * from './classes.streamfile.js';
-export * from './classes.virtualdirectory.js';
-export * from './classes.smartfile.factory.js';
+import * as plugins from "./smartfile.plugins";
+import * as SmartfileFs from "./smartfile.fs";
+import * as SmartfileInterpreter from "./smartfile.interpreter" 
+import * as SmartfileMemory from "./smartfile.memory";
+import * as SmartfileRemote from "./smartfile.remote";
 
-// Note: Filesystem operations (fs, memory, fsStream, interpreter) have been removed.
-// Use @push.rocks/smartfs for low-level filesystem operations.
-// Use SmartFileFactory for creating SmartFile/StreamFile/VirtualDirectory instances.
+export {Smartfile} from "./smartfile.classes.smartfile";
+
+export let fs = SmartfileFs;
+export let interpreter = SmartfileInterpreter;
+export let memory = SmartfileMemory;
+export let remote = SmartfileRemote;
+export let requireReload = SmartfileFs.requireReload;

ts/plugins.ts

@@ -1,38 +0,0 @@
-// node native scope
-import * as fs from 'fs';
-import * as fsPromises from 'fs/promises';
-import * as path from 'path';
-import * as stream from 'stream';
-
-export { fs, fsPromises, path, stream };
-
-// @pushrocks scope
-import * as lik from '@push.rocks/lik';
-import * as smartfileInterfaces from '@push.rocks/smartfile-interfaces';
-import * as smartdelay from '@push.rocks/smartdelay';
-import * as smarthash from '@push.rocks/smarthash';
-import * as smartjson from '@push.rocks/smartjson';
-import * as smartmime from '@push.rocks/smartmime';
-import * as smartpath from '@push.rocks/smartpath';
-import * as smartpromise from '@push.rocks/smartpromise';
-import * as smartrequest from '@push.rocks/smartrequest';
-import * as smartstream from '@push.rocks/smartstream';
-
-export {
-  lik,
-  smartfileInterfaces,
-  smartdelay,
-  smarthash,
-  smartjson,
-  smartmime,
-  smartpath,
-  smartpromise,
-  smartrequest,
-  smartstream,
-};
-
-// third party scope
-import * as glob from 'glob';
-import yaml from 'js-yaml';
-
-export { glob, yaml };

ts/smartfile.classes.smartfile.ts

@@ -0,0 +1,5 @@
+export class Smartfile {
+    constructor(){
+        
+    };
+}

ts/smartfile.fs.ts

@@ -0,0 +1,288 @@
+import "typings-global";
+
+import plugins = require("./smartfile.plugins");
+import SmartfileInterpreter = require("./smartfile.interpreter");
+
+/*===============================================================
+============================ Checks =============================
+===============================================================*/
+
+/**
+ *
+ * @param filePath
+ * @returns {boolean}
+ */
+export let fileExistsSync = function(filePath):boolean {
+    let fileExistsBool:boolean = false;
+    try {
+        plugins.fsExtra.readFileSync(filePath);
+        fileExistsBool = true
+    }
+    catch(err){
+        fileExistsBool = false;
+    }
+    return fileExistsBool;
+};
+
+/**
+ *
+ * @param filePath
+ * @returns {any}
+ */
+export let fileExists = function(filePath){
+    let done = plugins.Q.defer();
+    plugins.fs.access(filePath, plugins.fs.R_OK, function (err) {
+        err ? done.reject(err) : done.resolve();
+    });
+    return done.promise;
+};
+
+/**
+ * Checks if given path points to an existing directory
+ */
+export let isDirectory = function(pathArg):boolean{
+    return plugins.fsExtra.statSync(pathArg).isDirectory();
+};
+
+/**
+ * Checks if a given path points to an existing file
+ */
+export let isFile = function(pathArg):boolean{
+    return plugins.fsExtra.statSync(pathArg).isFile();
+};
+
+/*===============================================================
+============================ FS ACTIONS =========================
+===============================================================*/
+
+/**
+ * ensures that a directory is in place
+ */
+export let ensureDir = (dirPathArg:string) => {
+    let done = plugins.Q.defer();
+    plugins.fsExtra.ensureDir(dirPathArg,done.resolve);
+    return done.promise;
+}
+
+/**
+ * ensures that a directory is in place
+ */
+export let ensureDirSync = (dirPathArg:string) => {
+    plugins.fsExtra.ensureDirSync(dirPathArg);
+}
+
+/**
+ * copies a file from A to B on the local disk
+ */
+export let copy = function(fromArg:string, toArg:string){
+    var done = plugins.Q.defer();
+    plugins.fsExtra.copy(fromArg,toArg,{},function(){
+        done.resolve();
+    });
+    return done.promise;
+};
+
+/**
+ * copies a file SYNCHRONOUSLY from A to B on the local disk
+ */
+export let copySync = function(fromArg:string,toArg:string):boolean{
+    plugins.fsExtra.copySync(fromArg,toArg);
+    return true;
+};
+ 
+ /**
+  * removes a file or folder from local disk
+  */
+export let remove = function(pathArg:string){
+    var done = plugins.Q.defer();
+    plugins.fsExtra.remove(pathArg,function(){
+        done.resolve();
+    });
+    return done.promise;
+};
+
+/**
+ * removes a file SYNCHRONOUSLY from local disk
+ */
+export let removeSync = function(pathArg:string):boolean{
+    plugins.fsExtra.removeSync(pathArg);
+    return true;
+};
+
+
+/*===============================================================
+============================ Write/Read =========================
+===============================================================*/
+
+/**
+ *
+ * @param filePathArg
+ * @returns {*}
+ */
+export let toGulpStreamSync = function(filePathArg:string){
+    let stream = plugins.gulp.src(filePathArg);
+    return stream;
+};
+
+export let toGulpDestSync = function(folderPathArg:string){
+    return plugins.gulp.dest(folderPathArg);
+};
+
+/**
+ *
+ * @param filePathArg
+ * @param fileTypeArg
+ * @returns {any}
+ */
+export let toObjectSync = function(filePathArg,fileTypeArg?) {
+    let fileString = plugins.fsExtra.readFileSync(filePathArg, 'utf8');
+    let fileType;
+    fileTypeArg ? fileType = fileTypeArg : fileType = SmartfileInterpreter.filetype(filePathArg);
+    return SmartfileInterpreter.objectFile(fileString,fileType);
+};
+
+/**
+ * reads a file content to a String
+ * @param filePath
+ * @returns {string|Buffer|any}
+ */
+export let toStringSync = function(filePath) {
+    let fileString;
+    fileString = plugins.fsExtra.readFileSync(filePath, "utf8");
+    return fileString;
+};
+
+/**
+ *
+ * @param filePathArg
+ * @param options
+ * @returns {number}
+ */
+export let toVinylSync = function(filePathArg,options = {}) {
+    return plugins.vinylFile.readSync(filePathArg,options);
+};
+
+/**
+ * lets you reload files hot.
+ * @param path
+ * @returns {any}
+ */
+export let requireReload = function(path:string){
+    return plugins.requireReload(path);
+};
+
+/**
+ * lists Folders in a directory on local disk
+ * @returns Promise
+ */
+export let listFolders = function(pathArg:string,regexFilter?:RegExp){
+    let done = plugins.Q.defer();
+    let folderArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
+        return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
+    });
+    if(regexFilter){
+        folderArray = folderArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    }
+    done.resolve(folderArray);
+    return done.promise;
+};
+
+/**
+ * lists Folders SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export let listFoldersSync = function(pathArg:string,regexFilter?:RegExp):string[]{
+    let folderArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
+        return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isDirectory();
+    });
+    if(regexFilter){
+        folderArray = folderArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    return folderArray;
+};
+
+
+/**
+ * lists Files in a directory on local disk
+ * @returns Promise
+ */
+export let listFiles = function(pathArg:string, regexFilter?:RegExp){
+    let done = plugins.Q.defer();
+    let fileArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
+        return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
+    });
+    if(regexFilter){
+        fileArray = fileArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    done.resolve(fileArray);
+    return done.promise;
+};
+
+/**
+ * lists Files SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export let listFilesSync = function(pathArg:string, regexFilter?:RegExp):string[]{
+    let fileArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
+        return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
+    });
+    if(regexFilter){
+        fileArray = fileArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    return fileArray;
+};
+
+/**
+ * lists all items (folders AND files) in a directory on local disk
+ * @returns Promise
+ */
+export let listAllItems = function(pathArg:string, regexFilter?:RegExp){
+    let done = plugins.Q.defer();
+    let allItmesArray = plugins.fsExtra.readdirSync(pathArg);
+    if(regexFilter){
+        allItmesArray = allItmesArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    done.resolve(allItmesArray);
+    return done.promise;
+};
+
+/**
+ * lists all items (folders AND files) SYNCHRONOUSLY in a directory on local disk
+ * @returns an array with the folder names as strings
+ */
+export let listAllItemsSync = function(pathArg:string, regexFilter?:RegExp):string[]{
+    let allItmesArray = plugins.fsExtra.readdirSync(pathArg).filter(function(file) {
+        return plugins.fsExtra.statSync(plugins.path.join(pathArg, file)).isFile();
+    });
+    if(regexFilter){
+        allItmesArray = allItmesArray.filter((fileItem) => {
+            return regexFilter.test(fileItem);
+        });
+    };
+    return allItmesArray;
+};
+
+export let listFileTree = (dirPath:string, miniMatchFilter:string) => {
+    let done = plugins.Q.defer();
+    let options = {
+        cwd:dirPath
+    }
+    plugins.glob(miniMatchFilter,options,(err,files:string[]) => {
+        if(err){
+            console.log(err);
+            done.reject(err);
+        };
+        done.resolve(files);
+    });
+    return done.promise;
+};

ts/smartfile.interpreter.ts

@@ -0,0 +1,22 @@
+import "typings-global";
+
+import plugins = require("./smartfile.plugins");
+
+export let filetype = (pathArg:string):string => {
+    let extName = plugins.path.extname(pathArg);
+    let fileType = extName.replace(/\.([a-z]*)/,"$1"); //remove . form fileType
+    return fileType;
+};
+
+export let objectFile = (fileStringArg:string, fileTypeArg) => {
+    switch (fileTypeArg) {
+        case "yml" :
+        case "yaml":
+            return plugins.yaml.safeLoad(fileStringArg);
+        case "json":
+            return JSON.parse(fileStringArg);
+        default:
+            plugins.beautylog.error("file type " + fileTypeArg.blue + " not supported");
+            break;
+    }
+}

ts/smartfile.memory.ts

@@ -0,0 +1,133 @@
+import "typings-global";
+
+import plugins = require("./smartfile.plugins");
+import SmartfileInterpreter = require("./smartfile.interpreter");
+import vinyl = require("vinyl");
+let Readable = require("stream").Readable;
+/**
+ * allows you to create a gulp stream
+ * from String, from an Array of Strings, from Vinyl File, from an Array of VinylFiles
+ * @param fileArg
+ * @returns stream.Readable
+ * @TODO: make it async;
+ */
+export let toGulpStream = function(fileArg:string|string[]|plugins.vinyl|plugins.vinyl[],baseArg:string = "/"){
+    let fileArray = [];
+
+    if(typeof fileArg === "string" || fileArg instanceof plugins.vinyl){ // make sure we work with an array later on
+        fileArray.push(fileArg);
+    } else if (Array.isArray(fileArg)){
+        fileArray = fileArg;
+    } else {
+        throw new Error("fileArg has unknown format");
+    }
+
+    let vinylFileArray:plugins.vinyl[] = []; //we want to have an array of vinylFiles
+
+    for (let fileIndexArg in fileArray){ //convert fileArray in vinylArray
+        let file = fileArray[fileIndexArg];
+        file instanceof plugins.vinyl ?
+            vinylFileArray.push(file) :
+            vinylFileArray.push(toVinylFileSync(file,{filename:fileIndexArg,base:baseArg}));
+    };
+
+    let stream = new Readable({ objectMode: true });
+    for(let vinylFileIndexArg in vinylFileArray){
+        let vinylFile = vinylFileArray[vinylFileIndexArg];
+        stream.push(vinylFile);
+    };
+    stream.push(null); //signal end of stream;
+    return stream;
+};
+
+/**
+ * converts file to Object
+ * @param fileStringArg
+ * @param fileTypeArg
+ * @returns {any|any}
+ */
+export let toObject = function(fileStringArg:string,fileTypeArg:string){
+    return SmartfileInterpreter.objectFile(fileStringArg,fileTypeArg);
+};
+
+/**
+ * takes a string and converts it to vinyl file
+ * @param fileArg
+ * @param optionsArg
+ */
+export let toVinylFileSync = function(fileArg:string,optionsArg?:{filename?:string,base?:string,relPath?:string}){
+    optionsArg? void(0) : optionsArg = {filename: "vinylfile", base: "/"};
+    optionsArg.filename ? void(0) : optionsArg.filename = "vinylfile";
+    optionsArg.base ? void(0) : optionsArg.base = "/";
+    optionsArg.relPath ? void("0") : optionsArg.relPath = "";
+    let vinylFile = new plugins.vinyl({
+        base: optionsArg.base,
+        path: plugins.path.join(optionsArg.base,optionsArg.relPath,optionsArg.filename),
+        contents: new Buffer(fileArg)
+    });
+    return vinylFile;
+};
+
+/**
+ * takes a string array and some options and returns a vinylfile array
+ * @param arrayArg
+ * @param optionsArg
+ */
+export let toVinylArraySync = function(arrayArg:string[],optionsArg?:{filename?:string,base?:string,relPath?:string}){
+    let vinylArray = [];
+    for(let stringIndexArg in arrayArg){
+        let myString = arrayArg[stringIndexArg];
+        vinylArray.push(toVinylFileSync(myString,optionsArg));
+    }
+    return vinylArray;
+};
+
+
+/**
+ * takes a vinylFile object and converts it to String
+ */
+export let toStringSync = function(fileArg:plugins.vinyl){
+    return fileArg.contents.toString("utf8");
+};
+
+
+/**
+ * writes string or vinyl file to disk.
+ * @param fileArg
+ * @param fileNameArg
+ * @param fileBaseArg
+ */
+export let toFs = function(fileContentArg:string|vinyl,filePathArg){
+    let done = plugins.Q.defer();
+
+    //function checks to abort if needed
+    if (!fileContentArg || !filePathArg) throw new Error("expected valid arguments");
+
+    // prepare actual write action
+    let fileString:string;
+    let filePath:string = filePathArg;
+    if (fileContentArg instanceof plugins.vinyl){
+        fileString = toStringSync(fileContentArg);
+    } else if (typeof fileContentArg === "string") {
+        fileString = fileContentArg;
+    }
+    plugins.fsExtra.writeFile(filePath,fileString,"utf8",done.resolve);
+    return done.promise;
+};
+
+export let toFsSync = function(fileArg,filePathArg:string){
+    //function checks to abort if needed
+    if (!fileArg || !filePathArg) throw new Error("expected a valid arguments");
+
+    // prepare actual write action
+    let fileString:string;
+    let filePath:string = filePathArg;
+
+    if (fileArg instanceof plugins.vinyl){
+        fileString = toStringSync(fileArg);
+    } else if (typeof fileArg === "string") {
+        fileString = fileArg;
+    }
+    plugins.fsExtra.writeFileSync(filePath,fileString,"utf8");
+};
+

ts/smartfile.plugins.ts

@@ -0,0 +1,16 @@
+import "typings-global";
+export import beautylog = require("beautylog");
+export import fs = require("fs");
+export import fsExtra = require("fs-extra");
+export let gulp = require("gulp");
+export let glob = require("glob");
+export let g = {
+    remoteSrc: require("gulp-remote-src")
+};
+export import path = require("path");
+export import Q = require("q");
+export import vinyl = require("vinyl");
+export let vinylFile = require("vinyl-file");
+export let yaml = require("js-yaml");
+export let request = require("request");
+export let requireReload = require("require-reload");

ts/smartfile.remote.ts

@@ -0,0 +1,65 @@
+import "typings-global";
+import plugins = require("./smartfile.plugins");
+import SmartfileInterpreter = require("./smartfile.interpreter");
+
+export let toFs = function(from:string,toPath:string) {
+    var done = plugins.Q.defer();
+    var stream = plugins.request(from).pipe(plugins.fsExtra.createWriteStream(toPath));
+    stream.on('finish',function(){
+        done.resolve(toPath);
+    });
+    return done.promise;
+};
+
+/**
+ *
+ * @param filePathArg
+ * @returns {*}
+ */
+export let toGulpStreamSync = function(filePathArg:string,baseArg:string){
+    let stream = plugins.g.remoteSrc(filePathArg, {
+        base: baseArg
+    });
+    return stream;
+};
+
+/**
+ *
+ * @param fromArg
+ * @returns {any}
+ */
+export let toObject = function(fromArg:string){
+    let done = plugins.Q.defer();
+    plugins.request.get(fromArg, function (error, response, bodyString) {
+        let returnObject;
+        if (!error && response.statusCode == 200) {
+            returnObject = SmartfileInterpreter.objectFile(bodyString,SmartfileInterpreter.filetype(fromArg));
+            done.resolve(returnObject);
+        } else {
+            console.log('could not get remote file from ' + fromArg);
+            returnObject = undefined;
+            done.reject(returnObject);
+        };
+    });
+    return done.promise;
+};
+
+/**
+ *
+ * @param fromArg
+ * @returns {any}
+ */
+export let toString = (fromArg:string) => {
+    let done = plugins.Q.defer();
+    plugins.request.get(fromArg, function (error, response, bodyString) {
+        if (!error && response.statusCode == 200) {
+            done.resolve(bodyString);
+        } else {
+            plugins.beautylog.error('could not get remote file from ' + fromArg);
+            bodyString = undefined;
+            done.reject(bodyString);
+        };
+    });
+    return done.promise;
+};
+

tsconfig.json

@@ -1,14 +0,0 @@
-{
-  "compilerOptions": {
-    "experimentalDecorators": true,
-    "useDefineForClassFields": false,
-    "target": "ES2022",
-    "module": "NodeNext",
-    "moduleResolution": "NodeNext",
-    "esModuleInterop": true,
-    "verbatimModuleSyntax": true,
-    "baseUrl": ".",
-    "paths": {}
-  },
-  "exclude": ["dist_*/**/*.d.ts"]
-}