oox 0.3.0-beta9 → 0.3.2

package/bin/loader.mjs

@@ -1,279 +1,392 @@
-
-import path from 'node:path'
-
-import os from 'node:os'
-
-import fs from 'node:fs'
-
-import { get as httpGet } from 'node:http'
-
-import { get as httpsGet } from 'node:https'
-
-import oox from '../index.mjs'
-
-
-
-function generateRPCProxyScript ( name, attributes = [ ] ) {
-
-    let attrExports = ''
-
-    for ( const attr of attributes ) {
-    
-        attrExports += `\nexport const ${attr} = proxyer.${attr}\n`
-    }
-    
-    const script = `
-import oox from 'oox'
-function RPC_${name} ( ) { }
-function dotCall ( name, action ) {
-	
-	return new Proxy ( RPC_${name}, {
-
-        get ( target, key ) {
-
-			return dotCall ( name, action ? action + '.' + key : key )
-		},
-		
-		has ( target, key ) { return true },
-		
-		apply ( target, thisArg, args ) {
-
-            return oox.rpc ( name, action, args )
-		}
-	} )
-}
-const proxyer = dotCall ( '${name}', '' )
-export default proxyer
-${attrExports}
-`
-
-    return script
-}
-
-
-
-function generateRPCProxyURL ( name, attributes ) {
-    
-    let searchText = ''
-
-    if ( attributes.length ) {
-
-        const search = new URLSearchParams ( )
-
-        for ( const attr of attributes ) {
-    
-            search.append ( 'attr', attr )
-        }
-
-        searchText = '?' + search.toString ( )
-    }
-
-    return `oox://rpc/${name}.mjs${searchText}`
-}
-
-
-
-function isWebURL ( url ) {
-
-    return url && ( url.startsWith ( 'https://' ) || url.startsWith ( 'http://' ) )
-}
-
-
-
-function isOOXURL ( url ) {
-
-    return url && url.startsWith ( 'oox://' )
-}
-
-
-
-/**
- * make ESModule support dynamic <export *> attributes import
- * @param {string} importerSpecifier the import url
- * @param {string} specifier parentURL
- * @returns {string[]}
- */
-function getImportAttributes ( importerSpecifier, specifier ) {
-
-    const attributes = [ ]
-
-    const contents = fs.readFileSync ( importerSpecifier, 'utf-8' )
-
-    // import * as xxx from "xxx"
-    const mergeImport = contents.match ( new RegExp ( `import.+\\*\\s*as\\s+(\\w+)\\s+from\\s*["']${specifier}["']` ) )
-
-    if ( mergeImport ) {
-
-        const mergeName = mergeImport [ 1 ]
-
-        const attributesIterator = contents.matchAll ( new RegExp ( `${mergeName}\\s*\\.\\s*(\\w+)`, 'g' ) )
-
-        for ( const caseItem of attributesIterator ) {
-
-            attributes.push ( caseItem [ 1 ] )
-        }
-    }
-
-    // import { a, b, c } from 'xxx'
-    const attributeImport = contents.match ( new RegExp ( `import.+{(.+)}\\s*from\\s*["']${specifier}["']` ) )
-
-    if ( attributeImport ) {
-
-        const definedAttributes = attributeImport [ 1 ].split ( ',' ).map ( v => v.trim ( ) ).filter ( v => !v.startsWith ( 'default' ) )
-        
-        attributes.push ( ...definedAttributes )
-    }
-
-    return Array.from ( new Set ( attributes ) )
-}
-
-
-
-/**
- * @param {string} specifier
- * @param {{
- *   conditions: string[],
- *   parentURL: string | undefined,
- * }} context
- * @param {Function} defaultResolve
- * @returns {Promise<{ url: string }>}
- */
-export async function resolve ( specifier, context, defaultResolve ) {
-
-    const defaultSpecifer = specifier
-
-    const { parentURL } = context
-
-    // HTTP & HTTPS
-    if ( isWebURL ( specifier ) ) {
-
-        return { url: specifier }
-    } else if ( isWebURL ( parentURL ) && ( specifier.startsWith ( '.' ) || specifier.startsWith ( '/' ) ) ) {
-
-        return { url: new URL ( specifier, parentURL ).href }
-    }
-
-    // OOX special alias for web package
-    if ( specifier === 'oox' ) {
-
-        return {
-            url: 'file://' + path.resolve ( './node_modules/oox/index.mjs' )
-        }
-    }
-
-    const { entryFile } = oox.config
-
-    // Relative specifier concat to absolute path
-    if ( specifier.startsWith ( '.' ) && parentURL ) {
-
-        specifier = path.posix.join ( path.dirname ( parentURL.replace ( 'file://', '' ) ), specifier )
-    }
-
-    // Windows pathname remove root sep
-    if ( os.platform ( ) === 'win32' && specifier.startsWith ( '/' ) ) {
-
-        specifier = specifier.replace ( '/', '' )
-    }
-
-    // OOX RPC Proxy URL generation
-    if ( !specifier.endsWith ( entryFile.path ) && entryFile.group && specifier.startsWith ( entryFile.group ) ) {
-
-        const subSpecifier = specifier.slice ( entryFile.group.length )
-
-        const matchResult = subSpecifier.match ( /^\/?([\w-]+)(\/index)?(\.m?js)?$/ )
-
-        if ( matchResult ) {
-
-            const importerSpecifier = parentURL.replace ( os.platform ( ) === 'win32' ? /file:\/+/ : 'file://', '' )
-            
-            const attributes = getImportAttributes ( importerSpecifier, defaultSpecifer )
-
-            return { url: generateRPCProxyURL ( matchResult [ 1 ], attributes ) }
-        }
-    }
-
-    // restore Windows specifier protocol
-    if ( os.platform ( ) === 'win32' && specifier.includes ( '/' ) && !specifier.startsWith ( 'file://' ) ) {
-
-        specifier = 'file://' + specifier
-    }
-
-    return defaultResolve ( specifier, context, defaultResolve )
-}
-
-
-
-/**
- * @param {string} url
- * @param {{
- *   format: string,
- * }} context If resolve settled with a `format`, that value is included here.
- * @param {Function} defaultLoad
- * @returns {Promise<{
- *   format: string,
- *   source: string | ArrayBuffer | SharedArrayBuffer | Uint8Array,
- * }>}
- */
-export async function load ( url, context, defaultLoad ) {
-
-    if ( isWebURL ( url ) || isOOXURL ( url ) ) {
-
-        return getSource ( url, context, defaultLoad )
-    }
-
-    return defaultLoad ( url, context, defaultLoad )
-}
-
-
-
-export function getFormat ( url, context, defaultGetFormat ) {
-
-    if ( isWebURL ( url ) || isOOXURL ( url ) ) {
-
-        return {
-            format: 'module'
-        }
-    }
-
-    return defaultGetFormat ( url, context, defaultGetFormat )
-}
-
-
-
-export function getSource ( url, context, defaultGetSource ) {
-
-    if ( isWebURL ( url ) ) {
-
-        const getMethod = url.startsWith ( 'https://' ) ? httpsGet : httpGet
-
-        return new Promise ( ( resolve, reject ) => getMethod ( url, res => {
-            let source = ''
-            res
-            .on ( 'data', chunk => source += chunk )
-            .on ( 'end', () => resolve ( { format: 'module', source } ) )
-        } ).on ( 'error', reject ) )
-    } else if ( isOOXURL ( url ) ) {
-
-        const mURL = new URL ( url )
-
-        if ( mURL.host === 'rpc' ) {
-
-            const regexp = /\/([\w-]+)\.mjs$/
-
-            const matchResult = mURL.pathname.match ( regexp )
-
-            // read all import attributes
-            const attributes = mURL.searchParams.getAll ( 'attr' )
-        
-            const source = generateRPCProxyScript ( matchResult [ 1 ], attributes )
-
-            return { format: 'module', source }
-        }
-    }
-  
-    return defaultGetSource ( url, context, defaultGetSource )
-}
-
-
-
-process.on ( 'unhandledRejection', console.error )
+
+import path from 'node:path'
+
+import os from 'node:os'
+
+import fs from 'node:fs'
+
+import { get as httpGet } from 'node:http'
+
+import { get as httpsGet } from 'node:https'
+
+const ooxConfig = { }
+
+function generateRPCProxyScript ( name, attributes = [ ] ) {
+
+    let attrExports = ''
+
+    for ( const attr of attributes ) {
+    
+        attrExports += `\nconst RPC_ATTR_${attr} = proxyer.${attr}\n`
+    }
+
+    attrExports += '\nexport {\n'
+
+    for ( const attr of attributes ) {
+    
+        attrExports += `\nRPC_ATTR_${attr} as ${attr},\n`
+    }
+
+    attrExports += '}\n'
+    
+    const script = `
+import oox from 'oox'
+const attrMap = Object.create ( null )
+function dotCall ( name, action ) {
+
+	return new Proxy ( function() {}, {
+
+        get ( target, key ) {
+            const attrKey = action ? action + '.' + key : key
+            if ( attrKey in attrMap ) {
+                return attrMap [ attrKey ]
+            }
+			const attrProxy = dotCall ( name, attrKey )
+            attrMap [ attrKey ] = attrProxy
+            return attrProxy
+		},
+		
+		has ( target, key ) { return true },
+		
+		apply ( target, thisArg, args ) {
+            return oox.rpc ( name, action, args )
+		}
+	} )
+}
+const proxyer = dotCall ( '${name}', '' )
+export default proxyer
+${attrExports}
+`
+
+    return script
+}
+
+
+
+function generateRPCProxyURL ( name, attributes ) {
+    
+    let searchText = ''
+
+    if ( attributes.length ) {
+
+        const search = new URLSearchParams ( )
+
+        for ( const attr of attributes ) {
+    
+            search.append ( 'attr', attr )
+        }
+
+        searchText = '?' + search.toString ( )
+    }
+
+    return `oox://rpc/${name}.mjs${searchText}`
+}
+
+
+
+function isWebURL ( url ) {
+
+    return url && ( url.startsWith ( 'https://' ) || url.startsWith ( 'http://' ) )
+}
+
+
+
+function isFileURL ( url ) {
+
+    return url && url.startsWith ( 'file://' )
+}
+
+
+
+function isOOXURL ( url ) {
+
+    return url && url.startsWith ( 'oox://' )
+}
+
+
+
+function pathCorrect ( path ) {
+
+    return os.platform ( ) === 'win32' && path.startsWith ( '/' ) ? path.replace ( '/', '' ) : path
+}
+
+
+
+/**
+ * make ESModule support dynamic <export *> attributes import
+ * @param {string} importerSpecifier the import url
+ * @param {string} specifier parentURL
+ * @returns {string[]}
+ */
+function getImportAttributes ( importerSpecifier, specifier ) {
+
+    const attributes = [ ]
+
+    const contents = fs.readFileSync ( importerSpecifier, 'utf-8' )
+
+    // import * as xxx from "xxx"
+    const mergeImport = contents.match ( new RegExp ( `import.+\\*\\s*as\\s+(\\w+)\\s+from\\s*["']${specifier}["']` ) )
+
+    if ( mergeImport ) {
+
+        const mergeName = mergeImport [ 1 ]
+
+        const attributesIterator = contents.matchAll ( new RegExp ( `${mergeName}\\s*\\.\\s*(\\w+)`, 'g' ) )
+
+        for ( const caseItem of attributesIterator ) {
+
+            attributes.push ( caseItem [ 1 ] )
+        }
+    }
+
+    // import { a, b, c } from 'xxx'
+    const attributeImport = contents.match ( new RegExp ( `import.+{(.+)}\\s*from\\s*["']${specifier}["']` ) )
+
+    if ( attributeImport ) {
+
+        const definedAttributes = attributeImport [ 1 ].split ( ',' ).map ( v => v.trim ( ) ).filter ( v => !v.startsWith ( 'default' ) )
+        
+        attributes.push ( ...definedAttributes )
+    }
+
+    return Array.from ( new Set ( attributes ) )
+}
+
+
+
+/**
+ * transform local call => RPC
+ * @param {string} originalSpecifier 
+ * @param {string} specifier 
+ * @param {string} parentURL 
+ * @returns 
+ */
+function ooxRPCImportTransform ( originalSpecifier, specifier, parentURL ) {
+
+    const { entryInfo, ignore } = ooxConfig
+
+    const url = new URL ( specifier )
+
+    const groupURL = entryInfo.group ? new URL ( 'file://' + path.resolve ( '/', entryInfo.group ) ) : null
+
+    // OOX RPC Proxy URL generation
+    if ( !specifier.endsWith ( entryInfo.path ) && groupURL && url.href.startsWith ( groupURL.href ) ) {
+
+        const name = url.href.slice ( groupURL.href.length ).split ( '/' ).filter ( v => v  ) [ 0 ].split ( '.' ) [ 0 ]
+
+        if ( ignore.includes ( name ) ) return null
+
+        const subSpecifier = url.href.slice ( groupURL.href.length )
+
+        const matchResult = subSpecifier.match ( /^\/?([\w-]+)(\/index)?(\.((\w?js)|(ts\w?)))?$/ )
+
+        if ( matchResult ) {
+
+            const importerSpecifier = parentURL.replace ( os.platform ( ) === 'win32' ? /file:\/+/ : 'file://', '' )
+
+            const attributes = getImportAttributes ( importerSpecifier, originalSpecifier )
+
+            return { shortCircuit: true, url: generateRPCProxyURL ( matchResult [ 1 ], attributes ) }
+        }
+    }
+
+    return null
+}
+
+
+
+/**
+ * Directory import supported
+ * Ignored '.ts|.js' suffix import supported
+ * @param {string} specifier 
+ * @returns {string}
+ */
+function directoryImportTransform ( specifier ) {
+
+    let filename = new URL ( specifier ).pathname
+
+    if ( os.platform ( ) === 'win32' && filename.startsWith ( '/' ) ) {
+
+        filename = filename.replace ( '/', '' )
+    }
+
+    const stat0 = fs.statSync ( filename, {
+        throwIfNoEntry: false
+    } )
+
+    if ( !stat0 || stat0.isDirectory ( ) ) {
+
+        const justNeedEntry = stat0 && stat0.isDirectory ( )
+
+        const dirname = justNeedEntry ? filename : path.dirname ( filename )
+
+        const stat1 = justNeedEntry ? stat0 : fs.statSync ( dirname, {
+            throwIfNoEntry: false
+        } )
+
+        // find entry file
+        if ( stat1 && stat1.isDirectory ( ) ) {
+
+            const paths = filename.split ( '/' )
+
+            const filenameWithoutExtension = justNeedEntry ? 'index' : paths.pop ( )
+
+            const matchEntryRegExp = new RegExp ( `^${filenameWithoutExtension}\\.((\\w?js)|(ts\\w?))$` )
+
+            const entries = fs.readdirSync ( dirname )
+
+            for ( const entry of entries ) {
+
+                if ( !matchEntryRegExp.test ( entry ) ) continue
+
+                paths.push ( entry )
+
+                specifier = 'file://' + paths.join ( '/' )
+
+                break
+            }
+        }
+    }
+
+    return specifier
+}
+
+
+
+/**
+ * NodeJS version 18 or higher
+ * @param {*} param0 
+ */
+export async function initialize ( { ooxConfig: config } ) {
+
+    if ( !config ) {
+
+        throw new Error ( 'Loader initialize failed' )
+    }
+
+    Object.assign ( ooxConfig, config )
+}
+
+
+
+/**
+ * @param {string} specifier
+ * @param {{
+ *   conditions: string[],
+ *   parentURL: string | undefined,
+ * }} context
+ * @param {Function} defaultResolve
+ * @returns {Promise<{ url: string }>}
+ */
+export async function resolve ( specifier, context, defaultResolve ) {
+
+    const originalSpecifier = specifier
+
+    const { parentURL } = context
+
+    // HTTP & HTTPS
+    if ( isWebURL ( specifier ) ) {
+
+        return { shortCircuit: true, url: specifier }
+    } else if ( isWebURL ( parentURL ) && ( specifier.startsWith ( '.' ) || specifier.startsWith ( '/' ) ) ) {
+
+        return { shortCircuit: true, url: new URL ( specifier, parentURL ).href }
+    }
+
+    // OOX special alias for web package
+    if ( specifier === 'oox' && !isFileURL ( parentURL ) ) {
+
+        const url = ( await defaultResolve ( specifier, {
+            conditions: [ 'node', 'import', 'module-sync', 'node-addons' ],
+            parentURL: import.meta.url
+        }, defaultResolve ) ).url
+
+        return {
+            shortCircuit: true,
+            url
+            // url: await import.meta.resolve ( specifier )
+        }
+    }
+
+    if ( !isFileURL ( specifier ) ) {
+
+        try {
+
+            specifier =  ( await defaultResolve ( specifier, context, defaultResolve ) ).url
+        } catch ( error ) {
+
+            if ( !isFileURL ( parentURL ) ) throw error
+
+            const _specifier = directoryImportTransform ( new URL ( specifier, parentURL ).href )
+
+            if ( _specifier === specifier ) throw error
+
+            specifier = _specifier
+        }
+    }
+
+    const ooxRPCTransform = ooxRPCImportTransform ( originalSpecifier, specifier, parentURL )
+
+    if ( ooxRPCTransform ) return ooxRPCTransform
+
+    return defaultResolve ( specifier, context, defaultResolve )
+}
+
+
+
+/**
+ * @param {string} url
+ * @param {{
+ *   format: string,
+ * }} context If resolve settled with a `format`, that value is included here.
+ * @param {Function} defaultLoad
+ * @returns {Promise<{
+ *   format: string,
+ *   source: string | ArrayBuffer | SharedArrayBuffer | Uint8Array,
+ * }>}
+ */
+export async function load ( url, context, defaultLoad ) {
+
+    if ( isWebURL ( url ) || isOOXURL ( url ) ) {
+
+        return getSource ( url, context, defaultLoad )
+    }
+
+    return defaultLoad ( url, context, defaultLoad )
+}
+
+
+
+export function getSource ( url, context, defaultGetSource ) {
+
+    if ( isWebURL ( url ) ) {
+
+        const getMethod = url.startsWith ( 'https://' ) ? httpsGet : httpGet
+
+        return new Promise ( ( resolve, reject ) => getMethod ( url, res => {
+            let source = ''
+            res
+            .on ( 'data', chunk => source += chunk )
+            .on ( 'end', () => resolve ( { shortCircuit: true, format: 'module', source } ) )
+        } ).on ( 'error', reject ) )
+    } else if ( isOOXURL ( url ) ) {
+
+        const mURL = new URL ( url )
+
+        if ( mURL.host === 'rpc' ) {
+
+            const regexp = /\/([\w-]+)\.mjs$/
+
+            const matchResult = mURL.pathname.match ( regexp )
+
+            // read all import attributes
+            const attributes = mURL.searchParams.getAll ( 'attr' )
+        
+            const source = generateRPCProxyScript ( matchResult [ 1 ], attributes )
+
+            return { shortCircuit: true, format: 'module', source }
+        }
+    }
+  
+    return defaultGetSource ( url, context, defaultGetSource )
+}