@makano/rew 1.2.53 → 1.2.54

package/lib/rew/const/opt.js

@@ -2,9 +2,10 @@ const execOptions = {
 	sharedContext: true,
 	resolveExtensions: ['.coffee', { ext: '.js', options: { type: 'js' } }, { ext: '.qrew', options: { qrew: true } }],
 	nativeRequire: false,
+	useImport: false,
 	cwdAlias: '$',
 	jsxPragma: 'createElement',
-	jsx: false,
+	jsx: false
 };
 
 module.exports.execOptions = execOptions;

package/lib/rew/functions/import.js

@@ -87,7 +87,7 @@ module.exports.imp = function (runPath, context) {
 			).context.module.exports;
 
 		if (ispkg) {
-			const pkg = getPackage(filename)(context);
+			const pkg = getPackage(filename)(context, options);
 			exports = pkg._onImport ? pkg._onImport() : pkg;
 		} else if (foundCache) {
 		} else if (type == 'coffee') {

package/lib/rew/functions/require.js

@@ -1,10 +1,26 @@
 const fs = require('fs');
 const path = require('path');
+const { execOptions } = require('../const/opt');
+const { wait } = require('./wait');
+
+const cahcedRequires = {};
+
+const doImp = (path) => wait(async () => await import(resolvedPath));
 
 module.exports.customRequire = function customRequire(modulePath, filePath) {
+	const pathname = modulePath;
+	if (modulePath.startsWith('./') || modulePath.startsWith('../') || path.isAbsolute(modulePath)) {
+		pathname = path.resolve(modulePath);
+	}
+	if(cahcedRequires[pathname]) {
+		return cahcedRequires[pathname];
+	}
 	const resolvedPath = resolveModulePath(modulePath, filePath);
 	if(!resolvedPath) throw new Error('Module '+modulePath+' not found');
-	return require(resolvedPath);
+	const r = cahcedRequires[resolvedPath] ? cahcedRequires[resolvedPath] : execOptions.useImport ? doImp(resolvedPath) : require(resolvedPath);
+	if(!cahcedRequires[resolvedPath]) cahcedRequires[resolvedPath] = r;
+	if(!cahcedRequires[pathname]) cahcedRequires[pathname] = r;
+	return r;
 };
 
 function resolveModulePath(modulePath, filePath) {

package/lib/rew/modules/compiler.js

@@ -115,18 +115,22 @@ function compileRewStuff(content, options) {
 		const token = tokens[i];
 		let { token: nextToken, n } = gnextToken(i, 1, tokens) || {};
 
-		if (token.type === 'IDENTIFIER' && token.value === 'opt') {
+
+		if (token.type === 'IDENTIFIER' && token.value === 'opt.set') {
 			const { token: nextNextToken } = gnextToken(i, 2, tokens) || {};
-			if (nextNextToken && nextNextToken.value == 'jsxPragma') {
+			if (nextNextToken && nextNextToken.value.slice(1).slice(0, -1) == 'jsxPragma') {
 				const { token: nextLastToken } = gnextToken(i, 5, tokens) || {};
 				execOptions.jsxPragma = nextLastToken.value.slice(1).slice(0, -1);
 			}
 		}
 
-		if (token.type === 'COMMENT' && token.value.slice(1).trim() === '@jsx') {
+		if (token.type === 'COMMENT' && token.value.slice(1).trim().startsWith('@jsx')) {
 			options.jsx = true;
+			if(token.value.split('@jsx')[1].trim()){
+				options.jsxPragma = token.value.split('@jsx')[1].trim();
+			}
 		}
-
+		
     if (token.type === 'COMMENT' && token.value.slice(1).trim() === '@cls') {
 			options.cls = true;
 		}
@@ -146,7 +150,7 @@ function compileRewStuff(content, options) {
 		}
 
 
-		if (token.type === 'IDENTIFIER' && token.value === 'let') {
+		if (token.type === 'IDENTIFIER' && token.value === 'let' && !options.keepImports) {
 			result += '`'
 			hooks.push({
 				index: fnextToken(i, tokens, 'OTHER', ';').ti,
@@ -154,11 +158,11 @@ function compileRewStuff(content, options) {
 			});
 		}
 
-		if (token.type === 'IDENTIFIER' && token.value === 'export') {
+		if (token.type === 'IDENTIFIER' && token.value === 'export' && !options.keepImports) {
 			token.value = 'pub';
 		}
 
-		if (token.type === 'IDENTIFIER' && token.value === 'import') {
+		if (token.type === 'IDENTIFIER' && token.value === 'import' && !options.keepImports) {
 			// console.log(nextToken.type);
 			let ind = i + n + 2;
 
@@ -224,7 +228,7 @@ function compileRewStuff(content, options) {
 			nextToken &&
 			nextToken.type === 'IDENTIFIER' &&
 			nextToken.value &&
-			nextToken.value !== 'undefined'
+			nextToken.value !== 'undefined' && !options.keepImports
 		) {
 			let next = {...nextToken};
 			if(next.value == 'default'){
@@ -259,13 +263,13 @@ const cpl = (module.exports.compile = function (file, options = {}) {
 	let c = options.type == 'js' || options.compile == false ? file.content : compile(compileRewStuff(file.content, options), {
 		...options,
 		filename: file.path,
-		bare: false,
+		bare: options.bare ?? false,
 		inlineMap: false,
-	});
+	});2
 	// console.log(c);
 	if (execOptions.jsx || options.jsx) {
 		c = babel.transformSync(c, {
-			presets: [[babelReact, { pragma: execOptions.jsxPragma }]],
+			presets: [[babelReact, { pragma: options.jsxPragma || execOptions.jsxPragma }]],
 			plugins: [],
 		}).code;
 	}
@@ -273,7 +277,8 @@ const cpl = (module.exports.compile = function (file, options = {}) {
 });
 
 module.exports.compileFile = function (filepath, options = {}) {
-	const f = getFile(filepath);
+	const f = typeof filepath == "object" ? filepath : getFile(filepath);
+	if(typeof filepath == "object") filepath = filepath.path;
 	let qrew = false;
 
 	if(options.qrew || path.extname(filepath) == '.qrew') {

package/lib/rew/modules/context.js

@@ -25,7 +25,7 @@ module.exports.prepareContext = function (
       imports: [],
     },
     imports: {
-      meta: {},
+      meta: { url: new URL('file://'+filepath), main: isMainFile(filepath) },
       assert: options.import ?? {},
     },
     app: findAppInfo(filepath),

package/lib/rew/modules/runtime.js

@@ -1,5 +1,5 @@
 const vm = require('vm');
-const { compileFile } = require('./compiler');
+const { compileFile, compile } = require('./compiler');
 const { prepareContext } = require('./context');
 const { existsSync, readFileSync } = require('fs');
 const { CONFIG_PATH } = require('../const/config_path');
@@ -7,37 +7,36 @@ const path = require('path');
 
 const preScript = readFileSync(path.join(__dirname, '../const/pre-exec.js'), { encoding: 'utf-8' });
 
-const exec = (module.exports.exec = function (code, context) {
-	return vm.runInNewContext(code, vm.createContext(context), {
+const exec = (module.exports.exec = function (code, context, original = '') {
+	return vm.runInNewContext(code, context.do ? null : vm.createContext(context), {
 		filename: context.module.filepath,
-		lineOffset: -1 - preScript.split('\n').length,
+		lineOffset: (original.split('\n').length + preScript.split('\n').length) - code.split('\n').length,
 		displayErrors: true,
 	});
 });
 
 module.exports.runPath = function runPath(filepath, options = {}, custom_context = {}) {
 	if(filepath.endsWith('.js')) options.type = 'js';
-	let { compiled_code, file } = compileFile(filepath, options);
-	const context = prepareContext(custom_context, options, file.path, runPath);
-
-	context.module.compiled = compiled_code;
-	context.process.exit = (int) => process.exit(int);
+	let { compiled_code, file } = compileFile(options.code ? { content: options.code, path: filepath } : filepath, options);
+	const context = options.import?.takeThisContext ? custom_context : prepareContext(custom_context, options, file.path, runPath);
+	// context.module.compiled = compiled_code;
+	// context.process.exit = (int) => process.exit(int);
 
 	if(context.app){
 		const p = path.join(CONFIG_PATH, context.app.config.manifest.package, 'app');
 		if(existsSync(p) && context.app.path !== p){
 			console.log("App with the same package name has been installed. Conflicts happened. \nTo fix this, change your app's package name or remove the app making the conflict.");
 			return {
-				context: { exports: null },
+				context: { module: { exports: null } },
 				returns: null
 			}
 		}
 	}
 
-	compiled_code = preScript+compiled_code;
+	compiled_code = preScript+'\n'+compiled_code;
 
 	return {
 		context,
-		returns: exec(compiled_code, context),
+		returns: exec(compiled_code, context, file.content),
 	};
 };

package/lib/rew/pkgs/serve.js

@@ -0,0 +1,347 @@
+const { readdirSync, existsSync } = require('fs');
+const http = require('http');
+const { IttyRouter, AutoRouter, Router, createResponse, cors, error, StatusError, html, json, withCookies, withContent, withParams, jpeg, png, webp, text, status } = require('itty-router');
+const path = require('path');
+const { run } = require('../main');
+const { runPath } = require('../modules/runtime');
+module.exports = (context) => {
+
+  // http.createServer((req, res) => {
+  //   res.end();
+  // }).listen(1400);
+
+  const imp = (file) => context.imp(file);
+  const Web = imp('web');
+
+  function mkReq(req) {
+    const url = `http://${req.headers.host}${req.url}`;
+    const options = {
+      method: req.method,
+      headers: req.headers,
+      body: req.body
+    };
+  
+    return new Request(url, options);
+  }
+
+  class Server {
+    _server = {};
+    routers = {};
+
+    constructor(options){
+      this.options = options;
+      this._server = http.createServer((req, res) => {
+        options.handler ? options.handler(req, res) : this.handleRequest(req, res);
+      });
+      if(options.routers){
+        options.routers.forEach(router => router.to(this));
+      }
+    }
+  
+    async handleRequest(req, res){ 
+      try {
+        let response = new Response();
+        const request = mkReq(req);
+        if(this.options.fetch == 'router'){
+          if(!Object.keys(this.options.routers).length) throw new Error('No fetch function nor routers found');
+          response = await this.options.routers[Object.keys(this.options.routers)[0]].fetch(request);
+        } else {
+          response = await this.options.fetch(request);
+        }
+
+        if(!response){
+          res.end('Cannot '+req.method+' '+req.url);
+          return;
+        }
+
+        response.headers.forEach((value, name) => {
+          res.setHeader(name, value);
+        });
+        
+        res.writeHead(response.status);
+  
+        const buffer = await response.arrayBuffer();
+        res.end(Buffer.from(buffer));
+      } catch (error) {
+        // Handle errors
+        console.error("Error:", error);
+        res.writeHead(500, {'Content-Type': 'text/plain'});
+        res.end("Internal Server Error");
+      }
+    }
+    
+    get listen(){
+      this._server.listen(this.options.port);
+      return this;
+    }
+
+    set listen(port){
+      this.options.port = port;
+      return this;
+    }
+
+    port(port){
+      this.listen = port;
+      return this;
+    }
+
+    log(string){
+      console.log(string.replace(/\$([A-Za-z0-9_]+)/g, (_, name) => this.options[name] || _));
+      return this;
+    }
+  }
+
+  class SvrRouter {
+    static new(Class, options, props){
+      const router = Class(options);
+      for(let i in props) router[i] = props[i];
+      router.to = (server) => {
+        if(server instanceof Server){
+          server.routers[this.id] = this;
+        }
+      };
+      return router;
+    }
+  }
+
+  function findLayoutFiles(filePath, root, isClientSide = true, resolveExtensions = ['.coffee', '.js', '.jsx']) {
+    const layouts = [];
+    const rootDir = root;
+    let currentDir = path.dirname(filePath);
+  
+    while (currentDir !== rootDir) {
+      for (const ext of resolveExtensions) {
+        const layoutFile = path.join(currentDir, `layout${isClientSide ? '' : '.s'}${ext}`);
+        if (existsSync(layoutFile)) {
+          layouts.push(layoutFile);
+        }
+      }
+      currentDir = path.dirname(currentDir);
+    }
+    
+    for (const ext of resolveExtensions) {
+      const layoutFile = path.join(currentDir, `layout${isClientSide ? '' : '.s'}${ext}`);
+      if (existsSync(layoutFile)) {
+        layouts.push(layoutFile);
+      }
+    }
+  
+    return layouts.reverse();
+  }  
+
+  const defaultBundlerEntry = (file, layouts, data) => `
+  import * as target from "${file}";
+  ${layouts.map((layout, ind) => `import * as layout${ind} from "${layout}";`).join('\n')}
+  let page = target.render ? target.render(${JSON.stringify(data)}) : target.default ? target.default(${JSON.stringify(data)}) : null;
+  ${layouts.reverse().map((_, ind) => `if (layout${ind}.render) page = layout${ind}.render(${JSON.stringify(data)}, page);`).join('\n')}
+  `;
+  
+  const defaultSsrBundlerEntry = (file, layouts, data) => `
+  files = "${layouts.join(',')},${file}".split(',')
+
+  renderers = []
+
+  for key, file of files
+    renderers.push imp file
+
+  render = (data) -> 
+    page = renderers.pop().render(data)
+    for renderer in renderers
+      page = renderer.render data, page
+    page
+
+  exports { render }
+  `;
+
+  function createFileRouter({
+    onError = () => error(404, 'Path not found'),
+    root = '',
+    basePath = '',
+    resolveExtensions = ['.coffee', '.js', '.jsx'],
+    bundlerOptions = {},
+    bundlerEntry = defaultBundlerEntry,
+    ssrBundlerEntry = defaultSsrBundlerEntry,
+  }) {
+  
+    const lookUpFiles = ['route', 'page', 'page.s', 'page.ss'];
+
+    const params = {};
+  
+    function lookUp(pathname) {
+      const routeParts = pathname.split('/').filter(Boolean);
+      let routePath = root;
+
+      Object.keys(params).forEach(key => delete params[key]);
+    
+      for (const part of routeParts) {
+        const dir = readdirSync(routePath);
+    
+        const match = dir.find(d => d === part || d.match(/^\[.*\]$/));
+        if (!match) return null;
+
+        if (match.match(/^\[.*\]$/)) {
+          const paramName = match.slice(1, -1);
+          params[paramName] = part;
+        }
+    
+        routePath = path.join(routePath, match);
+      }
+      
+      for (const base of lookUpFiles) {
+        for (const ext of resolveExtensions) {
+          const filePath = path.join(routePath, `${base}${ext}`);
+          if (existsSync(filePath)) {
+            return filePath;
+          }
+        }
+      }
+      
+      return null;
+    }
+
+    function getReqProps(req) {
+      return {
+        params: {
+          ...params,
+          ...(req.params || {})
+        },
+        query: req.query,
+        url: req.url,
+        method: req.method
+      }
+    }
+
+    const w = new Web();
+
+    async function renderPage(file, basename, req){
+      const page = w.create({ viewportMeta: true });
+      if(basename.endsWith('.s') || basename.endsWith('.ss')){
+        // SSR is enabled, do only ssr
+        const layouts = findLayoutFiles(file, root, false);
+        const fileContext = runPath(file, { code: ssrBundlerEntry(file, layouts) }).context.module.exports || {};
+        if(typeof fileContext.render !== "function") throw new ReferenceError("Route does not export function render");
+        let pageContent = fileContext.render(req);
+        if(!w.isNode(pageContent)) throw new TypeError("Route.render does not return an element");
+        page.add(pageContent);
+      } else {
+        const layouts = findLayoutFiles(file, root, true);
+        const scriptString = await w.bundle(path.join(root, 'bundle.js'), {
+          ...bundlerOptions,
+          code: bundlerEntry(file, layouts, getReqProps(req))
+        });
+        page.script(scriptString);
+      }
+      return html(page.render(basename.endsWith('.ss')));
+    }
+  
+    async function handleRequest(req, file) {
+      const ext = path.extname(file);
+      const basename = path.basename(file, ext);
+  
+      if (basename.startsWith('route')) {
+        const fileContext = run(file).context;
+        const handlers = fileContext.module.exports;
+        const method = req.method.toUpperCase();
+        if (handlers[method]) {
+          return await handlers[method](req, getReqProps(req));
+        } else {
+          return error(405, `Method ${method} not allowed`);
+        }
+      } else if (basename.startsWith('page')) {
+        return await renderPage(file, basename, req);
+      }
+    }
+  
+  
+    return async (req) => {
+      const url = new URL(req.url);
+      const pathname = basePath ? url.pathname.replace(new RegExp('^'+basePath), '') : url.pathname;
+      const file = lookUp(pathname);
+  
+      if (file) {
+        const response = handleRequest(req, file);
+        response.catch(() => onError());
+        return await response;
+      } else {
+        return onError();
+      }
+    };
+  }
+  
+
+  
+  class Svr {
+    create(options){
+      return new Server(options);
+    }
+
+    router({ id = '/', type = 'normal', ...options }){
+      let router;
+      if(type == 'default') router = SvrRouter.new(IttyRouter, {...options}, { id });
+      if(type == 'auto') router = SvrRouter.new(AutoRouter, {...options}, { id });
+      if(type == 'normal') router = SvrRouter.new(Router, {...options}, { id });
+
+      return router;
+    }
+
+    createResponse(format, transform, type = 'normal'){
+      return type == 'json' ? json(format, transform) : createResponse(format, transform);
+    }
+
+    html(string, options = {}){
+      return html(string, options);
+    }
+    
+    json(object, options = {}){
+      return json(object, options);
+    }
+
+    jpeg(image, options = {}){
+      return jpeg(image, options);
+    }
+
+    png(image, options = {}){
+      return png(image, options);
+    }
+
+    webp(image, options = {}){
+      return webp(image, options);
+    }
+    
+    text(string, options = {}){
+      return text(string, options);
+    }
+    
+    status(code, options = {}){
+      return status(code, options);
+    }
+
+    cors(options = {}){
+      return cors(options);
+    }
+
+    error(status, body){
+      return error(status, body);
+    }
+
+    createFileRouter(o){
+      return createFileRouter(o);
+    }
+  }
+
+  class SvrResponse extends Response {}
+  class SvrRequest extends Request {}
+
+  Svr.prototype.Response = SvrResponse;
+  Svr.prototype.Request = SvrRequest;
+  Svr.prototype.URL = URL;
+  Svr.prototype.StatusError = StatusError;
+
+  Svr.prototype.withContent = withContent;
+  Svr.prototype.withCookies = withCookies;
+  Svr.prototype.withParams = withParams;
+
+  IttyRouter
+  
+  return Svr;
+}

package/lib/rew/pkgs/stream.js

@@ -0,0 +1,10 @@
+const { Readable, Writable, Transform, Duplex, pipeline, finished } = require('stream');
+
+module.exports = (context) => ({
+  Readable,
+  Writable,
+  Transform,
+  Duplex,
+  pipeline,
+  finished
+})