@environment-safe/file 0.2.1 → 0.3.1

package/.husky/pre-commit

@@ -1,10 +1,11 @@
 #!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-#npm run lint
+npm run lint
 npm run path-test
 npm run headless-browser-path-test
-#npm run import-test
+npm run link-local-moka
+npm run import-test
 npm run headless-browser-test
 #npm run build-commonjs
 #npm run require-test

package/README.md

@@ -67,7 +67,7 @@ Roadmap
 -------
 
 - [x] - test existing suite in mac node
-- [ ] - test existing suite in in chrome + server
+- [x] - test existing suite in in chrome + server
 - [ ] - test existing suite in in chrome + file
 - [ ] - test existing suite in windows node
 - [ ] - test existing suite in linux node
@@ -111,3 +111,5 @@ All work is done in the .mjs files and will be transpiled on commit to commonjs
 
 If the above tests pass, then attempt a commit which will generate .d.ts files alongside the `src` files and commonjs classes in `dist`
 
+In order to run the `import-test`, you must link the local `moka`, which can be done with `npm run link-local-moka` This is normally solved via dependency hoisting except in the case where you are developing on the file API which has a circular dependency with `moka`.
+

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@environment-safe/file",
-    "version": "0.2.1",
+    "version": "0.3.1",
     "type": "module",
     "main": "dist/index.mjs",
     "module": "src/index.mjs",
@@ -65,6 +65,7 @@
         "shims": {
             "chai": "node_modules/chai/chai.js",
             "@environment-safe/runtime-context": "node_modules/@environment-safe/runtime-context/./src/index.mjs",
+            "@environment-safe/file": "./src/index.mjs",
             "browser-or-node": "node_modules/browser-or-node/src/index.js"
         }
     },
@@ -76,7 +77,7 @@
         "@environment-safe/chai": "^0.1.0",
         "@environment-safe/commonjs-builder": "^0.0.3",
         "@environment-safe/jsdoc-builder": "^0.0.2",
-        "@open-automaton/moka": "^0.5.0",
+        "@open-automaton/moka": "^0.5.1",
         "babel-plugin-search-and-replace": "^1.1.1",
         "babel-plugin-transform-import-meta": "^2.2.0",
         "chai": "^4.3.7",
@@ -109,6 +110,7 @@
         "container-test": "docker build . -t environment-safe-package.json -f ./containers/test.dockerfile; docker logs --follow \"$(docker run -d environment-safe-package.json)\"",
         "build-docs": "build-jsdoc docs",
         "build-types": "build-jsdoc types",
+        "link-local-moka":"npm link ../../@open-automaton/moka; cd ../../@open-automaton/moka; npm link ../../@environment-safe/file",
         "add-generated-files-to-commit": "git add docs/*.md; git add src/*.d.ts; git add dist/*.cjs",
         "prepare": "husky install"
     },

package/src/buffer.mjs

@@ -26,7 +26,7 @@ const base64ToArrayBuffer = (base64)=>{
         bytes[i] = binaryString.charCodeAt(i);
     }
     return bytes.buffer;
-}
+};
 
 if(isBrowser || isJsDom){
     InternalBuffer = function(value, type){
@@ -36,6 +36,16 @@ if(isBrowser || isJsDom){
     };
     const enc = new TextEncoder();
     const dec = new TextDecoder(); //'utf-8'
+    InternalBuffer.fromDataURI = async (url)=>{
+        if(typeof url === 'string' && url.startsWith('data:')){
+            const result = await fetch(url);
+            const buffer = await result.arrayBuffer();
+            return buffer;
+        }else{
+            throw new Error('not a data uri');
+        }
+    };
+    InternalBuffer.fromDataURL = InternalBuffer.fromDataURI;
     InternalBuffer.from = (ob)=>{
         const type = Array.isArray(ob)?'array':(typeof ob);
         if(InternalBuffer.is(ob)){
@@ -46,7 +56,6 @@ if(isBrowser || isJsDom){
             case 'array':
             case 'string':
                 return enc.encode(ob).buffer;
-                break;
             case '':
         }
     };
@@ -66,17 +75,30 @@ if(isBrowser || isJsDom){
                 result = toBinString(Uint8Array.from(buffer));
                 break;
             case 'base64':
-                result = btoa(InternalBuffer.to('binary-string', buffer));
+                var binary = '';
+                var bytes = new Uint8Array( buffer );
+                var len = bytes.byteLength;
+                for (var i = 0; i < len; i++) {
+                    binary += String.fromCharCode( bytes[ i ] );
+                }
+                result = btoa( binary );
                 break;
         }
         return result;
     };
     InternalBuffer.toString = (type, buffer)=>{
         let result = null;
-        if(type === 'base64'){
-            result = InternalBuffer.to(type, buffer);;
-        }else{
-            result = InternalBuffer.to('string', buffer);
+        switch(type){
+            case 'hex':
+                result = Array.prototype.map.call(
+                    new Uint8Array(buffer),
+                    x => ('00' + x.toString(16)).slice(-2)
+                ).join('').match(/[a-fA-F0-9]{2}/g).join('');
+                break;
+            case 'base64':
+                result = InternalBuffer.to(type, buffer);
+                break;
+            default: result = InternalBuffer.to('string', buffer);
         }
         return result;
     };
@@ -87,11 +109,12 @@ if(isBrowser || isJsDom){
                 result[lcv] = fill;
             }
         }
+        return result;
         //todo: convert encoding to byte offset
     };
 }else{
     InternalBuffer = function(value, type){
-        return new Buffer(value, type)
+        return new Buffer(value, type);
     };
     InternalBuffer.from = (ob='')=>{
         return Buffer.from(ob);
@@ -99,6 +122,16 @@ if(isBrowser || isJsDom){
     InternalBuffer.is = (buffer)=>{
         return Buffer.isBuffer(buffer);
     };
+    InternalBuffer.fromDataURI = async (url)=>{
+        if(typeof url === 'string' && url.startsWith('data:')){
+            const result = await fetch(url);
+            const buffer = await result.arrayBuffer();
+            return buffer;
+        }else{
+            throw new Error('not a data uri');
+        }
+    };
+    InternalBuffer.fromDataURL = InternalBuffer.fromDataURI;
     //InternalBuffer = Buffer;
     InternalBuffer.to = (type, buffer)=>{
         switch(type){
@@ -109,7 +142,7 @@ if(isBrowser || isJsDom){
             case 'string':
                 return buffer.toString();
             case 'base64':
-                return btoa(buffer.toString());
+                return buffer.toString('base64');
             case '':
             
         }
@@ -119,5 +152,18 @@ if(isBrowser || isJsDom){
         return InternalBuffer.to('string', buffer);
     };
 }
+InternalBuffer.stringify = (buffer, indent='  ', lineIndent='', lineSize=80)=>{
+    let pos = 0;
+    return InternalBuffer.toString('hex', buffer).split('').map((value, index)=>{
+        const chars = (pos%2 === 0 && pos !== 0)?indent+value:value;
+        if(pos + chars.length > lineSize){
+            const add = lineIndent+value;
+            pos = add.length;
+            return '\n'+add;
+        }
+        pos += chars.length;
+        return chars;
+    }).join('');
+};
 
 export const FileBuffer = InternalBuffer;

package/src/filesystem.mjs

@@ -16,6 +16,7 @@ const ensureRequire = ()=> (!internalRequire) && (internalRequire = mod.createRe
 // and we now have 4 an obvious indicator that we went wrong? (win, unix, file, known dirs)
  
 import { FileBuffer } from './buffer.mjs';
+import { File } from './index.mjs';
 import * as fs from 'fs';
 import { 
     isClient // is running a client
@@ -331,7 +332,9 @@ export const serverFile = {
                 const url = parsed.toUrl('native');
                 return await new Promise((resolve, reject)=>{
                     fs.readFile(url, (err, buffer)=>{
-                        if(err) return reject(err);
+                        if(err){
+                            reject(new Error(`File not found('${path}')`));
+                        }
                         resolve(buffer);
                     });
                 });
@@ -342,15 +345,17 @@ export const serverFile = {
                 return await new Promise((resolve, reject)=>{
                     fs.writeFile(url, buffer, (err)=>{
                         if(err) return reject(err);
-                        if(globalThis.handleWrite) globalThis.handleWrite({
-                            path,
-                            url,
-                            buffer,
-                            text: ()=>{
-                                return FileBuffer.toString('string', buffer)
-                            },
-                            arrayBuffer: ()=> buffer,
-                        }); 
+                        if(globalThis.handleWrite){
+                            globalThis.handleWrite({
+                                path,
+                                url,
+                                buffer,
+                                text: ()=>{
+                                    return FileBuffer.toString('string', buffer);
+                                },
+                                arrayBuffer: ()=> buffer,
+                            }); 
+                        }
                         resolve();
                     });
                 });
@@ -431,18 +436,19 @@ export const remote = {
             },
             read: async (path, options={})=>{
                 const response = await fetch(path);
+                if(response.status === 404) throw new Error(`File not found('${path}')`);
                 return await response.arrayBuffer();
             },
             write: async (path, buffer, options={})=>{
                 return await new Promise((resolve, reject)=>{
                     try{
                         var element = document.createElement('a');
-                        const type = options.mimeType || 'text/plain';
-                        const format = options.format || 'charset=utf-8';
+                        const type = options.mimeType || File.deriveMIMEType(buffer);
+                        const format = options.format || File.deriveFormat(type);
                         const representation = (
                             type === 'text/plain'?
-                            FileBuffer.toString('text', buffer):
-                            FileBuffer.toString('base64', buffer)
+                                FileBuffer.toString('text', buffer):
+                                FileBuffer.toString('base64', buffer)
                         );
                         const dataURI = `data:${type};${format},${representation}`;
                         element.setAttribute('href', dataURI);

package/src/index.mjs

@@ -131,33 +131,50 @@ const internalCache = {};
 
 const mimeTypes = [
     {
-        check: [0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a],
-        mime: 'image/png'
+        check: [0x89, 0x50, 0x4e, 0x47],
+        mime: 'image/png',
+        types: ['png']
     },
     {
         check: [0xff, 0xd8, 0xff],
-        mime: 'image/jpeg'
+        mime: 'image/jpeg',
+        types: ['jpg', 'jpeg']
     },
     {
         check: [0x47, 0x49, 0x46, 0x38],
-        mime: 'image/gif'
+        mime: 'image/gif',
+        types: ['gif']
     }
 ];
+const textMimeTypes = [
+    'text/plain'
+];
 
 const checkOne = (headers)=>{
-    return (buffers, options = { offset: 0 }) =>
-        headers.every(
-            (header, index) => header === buffers[options.offset + index]
-        );
+    return (buffers, options = { offset: 0 }) =>{
+        const array = new Uint8Array(buffers);
+        return headers.reduce((agg, value, index)=>{
+            return agg && value === array[options.offset + index];
+        }, true);
+    };
 };
 
 const checks = {};
 
+/*const mimeFromType = (path)=>{
+    const fileType = path.split('.').pop().toLowerCase();
+    const result = mimeTypes.reduce((agg, type)=>{
+        return agg || (type.types.indexOf(fileType) !== -1 && fileType)
+    }, false);
+    return result;
+};*/
+
 const mimeFromBuffer = (buffer)=>{
-    return mimeTypes.reduce((agg, type)=>{
+    const result = mimeTypes.reduce((agg, type)=>{
         if(!checks[type.check]) checks[type.check] = checkOne(type.check);
-        return agg || (checks[type.check](buffer) && type.mime)
+        return agg || (checks[type.check](buffer) && type.mime);
     }, false);
+    return result;
 };
 
 export class File{
@@ -170,7 +187,11 @@ export class File{
         this.options = options;
         //one of: desktop, documents, downloads, music, pictures, videos
         this.directory = options.directory || '.';
-        this.path = location;
+        if(location.startsWith('data:')){
+            this.dataURI = location;
+        }else{
+            this.path = location;
+        }
         this.setBuffer(FileBuffer.from(''));
     }
     
@@ -188,8 +209,14 @@ export class File{
     }
     
     async load(){
-        this.setBuffer(await read(this.path, this.options));
-        return this;
+        if(this.path){
+            const input = await read(this.path, this.options);
+            this.setBuffer(input);
+            return this;
+        }
+        if(this.dataURI){
+            this.setBuffer(await FileBuffer.fromDataURI(this.dataURI));
+        }
     }
     
     body(value){
@@ -207,13 +234,21 @@ export class File{
         return this.derivedMIMEType;
     }
     
+    isText(){
+        return textMimeTypes.indexOf(this.mimeType()) !== -1;
+    }
+    
     format(){
         if(!this.derivedMIMEType) this.mimeType();
         return File.deriveFormat(this.derivedMIMEType);
     }
     
     toDataURL(){
-        return `data:${this.mimeType()};${this.format()},${FileBuffer.toString('base64', this.body())}`
+        if(this.isText()){
+            return `data:${this.mimeType()};${this.format()},${FileBuffer.toString('string', this.body())}`;
+        }else{
+            return `data:${this.mimeType()};${this.format()},${FileBuffer.toString('base64', this.body())}`;
+        }
     }
     
     async info(){
@@ -246,6 +281,20 @@ export class File{
         return await exists(path, directory);
     }
     
+    static async similarity(fileA, fileB, strict){
+        //*
+        if(strict && fileA.buffer.byteLength !== fileB.buffer.byteLength){
+            throw new Error(`File lengths do not match! (${fileA.buffer.byteLength} != ${fileB.buffer.byteLength})`);
+        } //*/
+        const size = fileA.buffer.byteLength;
+        let total = 0;
+        let lcv=0;
+        for(lcv=0; lcv<size; lcv++){
+            if(fileA[lcv] === fileB[lcv]) total++;
+        }
+        return total/size;
+    }
+    
     static async list(path, options){
         return await list(path, options);
     }

package/test/test.mjs

@@ -1,7 +1,6 @@
 /* global describe:false */
-import { isServer } from '@environment-safe/runtime-context';
 import { chai } from '@environment-safe/chai';
-import { it, configure, interactive } from '@open-automaton/moka';
+import { it, configure, interactive, isInteractive } from '@open-automaton/moka';
 import { File, Path, Download } from '../src/index.mjs';
 const should = chai.should();
 
@@ -18,9 +17,6 @@ describe('@environment-safe/file', ()=>{
         const fileRelativeSaveName = Path.join(Path.location('downloads'), 'index.mjs');
         const missingFileRelativeName = Path.join('..', 'src', 'unknown.mjs');
         const download = new Download();
-        if(isServer){
-            
-        }
         configure({
             dialog : async (context, actions)=> await actions.confirm(), // OK everything,
             wantsInput : async (context, actions)=> await actions.click('#mocha'), // click everything
@@ -93,11 +89,15 @@ describe('@environment-safe/file', ()=>{
             await file.load();
             file.path = fileRelativeSaveName; //change path
             file.body('foo!'); //replace source
-            const anticipatedDownload = download.expect();
-            await file.save();
-            const result = await anticipatedDownload;
-            const downloadedText = await result.text();
-            downloadedText.should.equal('foo!');
+            if(!isInteractive){
+                // if the test is interactive, automated file hooks won't work
+                // so test without a download confirm
+                const anticipatedDownload = download.expect();
+                await file.save();
+                const result = await anticipatedDownload;
+                const downloadedText = await result.text();
+                downloadedText.should.equal('foo!');
+            }
         });
         
         it('loads an implicit, relative URL', async function(){
@@ -116,6 +116,53 @@ describe('@environment-safe/file', ()=>{
             await file.load();
             file.body().cast('string').length.should.be.above(1);
         });
+        
+        it('loads itself as data when text', async function(){
+            const file = new File(Path.join(
+                '../node_modules/@environment-safe/chai',
+                'README.md'
+            ));
+            await file.load();
+            const uri = file.toDataURL();
+            const copy = new File(uri);
+            await copy.load();
+            const similarity = await File.similarity(file, copy);
+            should.exist(similarity);
+            similarity.should.equal(1);
+        });
+        
+        it('loads itself as data when binary', async function(){
+            const file = new File('./aso.png');
+            await file.load();
+            const uri = file.toDataURL();
+            const copy = new File(uri);
+            await copy.load();
+            const similarity = await File.similarity(file, copy);
+            should.exist(similarity);
+            similarity.should.equal(1);
+        });
+        
+        it('can duplicate by copying buffer', async function(){
+            const file = new File('./aso.png');
+            await file.load();
+            const copy = new File();
+            copy.body(file.buffer);
+            const similarity = await File.similarity(file, copy, true);
+            should.exist(similarity);
+            similarity.should.equal(1);
+        });
+        
+        it('fails to load a non-existent file', async function(){
+            
+            try{
+                const file = new File('./woo.png');
+                await file.load();
+            }catch(ex){
+                ex.message.should.equal('File not found(\'./woo.png\')');
+                return;
+            }
+            should.not.exist(true, 'file did not error on load');
+        });
     });
 });