@makano/rew 1.2.73 → 1.2.75

package/lib/rew/const/opt.js

@@ -9,7 +9,9 @@ const execOptions = {
 	jsxPragma: '__using__.JSX.createElement',
 	jsx: false,
 	typescript: false,
-	decorators: false
+	decorators: false,
+
+	_syntaxAliases: {}
 };
 
 module.exports.execOptions = execOptions;

package/lib/rew/const/usage.js

@@ -29,18 +29,22 @@ module.exports.Usage = class Usage {
     return new Usage(name, trigger, save);
   }
 
-  group(group, props){
-    return new Usage.Group(group, props);
+  group(...group){
+    return new Usage.Group(group, {});
   }
 
   static Group = class UsageGroup {
-    g = [{}, () => {}]
-    constructor(g, props){
+    g = []
+    constructor(g, props = {}){
       this.g = g;
-      for(let i in props){
+      if(props) for(let i in props){
         this[i] = props[i];
       }
     }
+    
+    with(props){
+      return new UsageGroup(this.g, props);
+    }
   }
 }
 

package/lib/rew/modules/compiler.js

@@ -6,7 +6,7 @@ const { getFile, file } = require('./fs');
 const babel = require('@babel/core');
 const path = require('path');
 const babelReact = require('@babel/preset-react');
-const { readFileSync } = require('fs');
+const { readFileSync, existsSync } = require('fs');
 const { wait } = require('../functions/wait');
 const { REW_FILE_TYPE } = require('../const/ext');
 const { USING_DEFAULT } = require('../const/usage');
@@ -122,12 +122,43 @@ const fnextToken = (i, tokens, type, value) => {
 		.find((t) => t.type == type && (value ? t.value == value : true));
 };
 
+function declareAlias(aliases, token) {
+  const regex = /^#declare(\*)?\s+(\w+)\s+"([^"]+)"\s*=\s*([\s\S]*);$/;
+  const match = token.value.trim().match(regex);
+
+  if (match) {
+    const isPublic = !!match[1];
+    const type = match[2] == "key" ? 'IDENTIFIER' : match[2];
+    const name = match[3];
+    const value = match[4].trim();
+
+    const aliasValue = value.startsWith('${')
+      ? new Function('token', 'tokens', 'code', value.slice(2, -1))
+      : value;
+
+    aliases[type] = aliases[type] || {};
+    aliases[type][name] = aliasValue;
+
+		if(isPublic){
+			execOptions._syntaxAliases[type] = execOptions._syntaxAliases[type] || {};
+			execOptions._syntaxAliases[type][name] = aliasValue;
+		}
+  }
+}
+
 function compileRewStuff(content, options) {
 	const tokens = tokenizeCoffeeScript(content);
 	let result = '';
+  let multilineDeclareBuffer = [];
+  let multilineDeclare = false;
 
 	let hooks = [];
 
+
+	const aliases = {
+		...execOptions._syntaxAliases
+	}
+
 	for (let i = 0; i < tokens.length; i++) {
 		const token = tokens[i];
 		let { token: nextToken, n } = gnextToken(i, 1, tokens) || {};
@@ -136,6 +167,30 @@ function compileRewStuff(content, options) {
 			continue;
 		}
 
+    if ((token.type === "COMMENT" && multilineDeclare) || (token.type !== "COMMENT" && multilineDeclare)) {
+      if(token.type === "COMMENT"){
+				multilineDeclareBuffer.push(token.value.startsWith('###') ? token.value.slice(3) : token.value.slice(1));
+				if (token.value.includes(';')) {
+					multilineDeclare = false;
+					const combinedDeclaration = multilineDeclareBuffer.join('\n');
+					declareAlias(aliases, { ...token, value: combinedDeclaration });
+					multilineDeclareBuffer = [];
+				}
+			} else {
+				multilineDeclare = false;
+				multilineDeclareBuffer = [];
+			}
+    }
+
+		if (token.type === "COMMENT" && token.value.startsWith('#declare')) {
+      if (token.value.includes(';')) {
+        declareAlias(aliases, token);
+      } else {
+        multilineDeclare = true;
+        multilineDeclareBuffer.push(token.value);
+      }
+    }
+
 		if (token.type === 'IDENTIFIER' && token.value === 'opt.set') {
 			const { token: nextNextToken } = gnextToken(i, 2, tokens) || {};
 			if (nextNextToken && nextNextToken.value.slice(1).slice(0, -1) == 'jsxPragma') {
@@ -269,6 +324,17 @@ function compileRewStuff(content, options) {
 			});
 		}
 
+		const aliasType = aliases[token.type];
+    if (aliasType && aliasType[token.value]) {
+      const aliasValue = aliasType[token.value];
+      if (typeof aliasValue === 'function') {
+        result += aliasValue(token, tokens, result) || "";
+      } else {
+        result += aliasValue;
+      }
+      continue;
+    }
+
 		// if(token.type === 'TRIPLE_STRING'){
 		// 	token.value = '```'+token.value.slice(3).slice(0, -3).replace(/\#\{/g, '${')+'```';
 		// }
@@ -282,10 +348,19 @@ function compileRewStuff(content, options) {
 				}
 			});
 		}
+		
+		if (token.type === "COMMENT" && token.value.startsWith('#include')) {
+			const includeContent = token.value.split(' ')[1] || '';
+			const filename = options.filename ? path.resolve(path.dirname(options.filename), includeContent) : includeContent;
+			if (existsSync(filename)) {
+        result += '\n'+ compileRewStuff(readFileSync(filename).toString(), {
+					...options,
+					filename
+				});
+      }
+    }
 	}
 
-	// console.log(result)
-
 	return result;
 }
 
@@ -298,7 +373,10 @@ const compileCivetStuff = (file, options) => {
 		js: true
 	};
 
-	const prepared = compileRewStuff(file.content, options);
+	const prepared = compileRewStuff(file.content, {
+		filename: file.path,
+		...options
+	});
 	let compiled = options.async ? compileCivet(prepared, compileOptions) : wait(compileCivet, prepared, compileOptions);
 
 	return {

package/lib/rew/modules/context.js

@@ -107,7 +107,7 @@ module.exports.prepareContext = function (
 
   context.using = (name, ...params) => {
     if(name instanceof Usage.Group){
-      params.unshift(name.g[1])
+      params.unshift(...name.g.slice(1));
       name = name.g[0];
     }
     if(USING_DEFAULT[name]){

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.2.73",
+  "version": "1.2.75",
   "description": "A simple coffescript runtime and app manager",
   "main": "main.js",
   "directories": {

package/runtime.d.ts

@@ -953,5 +953,5 @@ declare class Usage<T = () => void> {
   save: boolean;
   constructor(name: string, trigger: T, save: boolean);
   create(name: string, trigger: T, save: boolean): Usage;
-  group<T = any[], U = any>(group: T, props?: U): { g: T, [key: string]: any }
+  group(...group: any[]): { g: T, with: (props: any) => { g: T, [key: string]: any }, [key: string]: any }
 }