oipage 0.1.0-alpha.1 → 0.1.0-alpha.3

package/corejs/throttle/index.d.ts

@@ -0,0 +1,31 @@
+export type throttleOpportunityType = "begin" | "end" | "wide"
+
+export interface throttleOptionType {
+
+    /**
+     * 节流时长
+     */
+    time?: number
+
+    /**
+     * 是否持续节流
+     */
+    keep?: boolean
+
+    /**
+     * 执行时机
+     *
+     * begin（开始触发）、end（结束触发）、wide（第一次开始触发，其余结束触发）
+     */
+    opportunity?: throttleOpportunityType
+
+}
+
+/**
+ * 节流函数
+ */
+export interface throttleType {
+    (callback: Function, option?: throttleOptionType): Function
+}
+
+export let throttle: throttleType

package/corejs/throttle/index.js

@@ -0,0 +1,50 @@
+export function throttle(callback, _option) {
+
+    // 缺省值
+    var option = {
+        time: 200,
+        keep: false,
+        opportunity: "end"
+    };
+
+    // 校对
+    if (_option) {
+        for (var key in _option) {
+            option[key] = _option[key];
+        }
+    }
+
+    var hadInterval = false, hadClick = false, oneClick = false, arg;
+    return function () {
+        const _this = this;
+        arg = arguments;
+
+        // 如果前置任务都完成了
+        if (!hadInterval) {
+            if (option.opportunity != 'end') {
+                callback.apply(_this, arg);
+            }
+            hadInterval = true;
+
+            var interval = setInterval(() => {
+                if (hadClick) {
+                    if (!option.keep) {
+                        callback.apply(_this, arg);
+                    }
+                } else {
+                    if (option.opportunity != 'begin') {
+                        if (oneClick || option.opportunity == 'end') callback.apply(_this, arg);
+                    }
+                    hadInterval = false;
+                    oneClick = false;
+                    clearInterval(interval);
+                }
+                hadClick = false;
+            }, option.time);
+        } else {
+            hadClick = true;
+            oneClick = true;
+        }
+
+    };
+};

package/nodejs/core/file.js

@@ -0,0 +1,128 @@
+const fs = require('fs');
+const path = require('path');
+
+// 删除文件或文件夹
+function deleteSync(target) {
+
+  // 如果文件夹不存在，直接返回即可
+  if (!fs.existsSync(target)) return;
+
+  // 如果是文件，直接删除即可
+  if (!fs.lstatSync(target).isDirectory()) {
+    fs.unlinkSync(target);
+  } else {
+
+    // 读取子文件
+    const subFiles = fs.readdirSync(target);
+
+    subFiles.forEach(function (file) {
+
+      // 调用这个方法，删除子文件或文件夹
+      const curPath = path.join(target, "./" + file);
+      deleteSync(curPath);
+
+    });
+
+    // 等子文件或文件夹删除完毕以后，删除本文件夹
+    fs.rmdirSync(target);
+  }
+
+};
+
+// 复制文件或文件夹
+function copySync(source, target) {
+
+  // 如果是文件，直接复制即可
+  if (!fs.lstatSync(source).isDirectory()) {
+    fs.copyFileSync(source, target);
+  } else {
+
+    // 读取子文件
+    const subFiles = fs.readdirSync(source);
+
+    // 如果文件夹不存在，创建
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    // 复制子文件或文件夹
+    subFiles.forEach(function (file) {
+      copySync(path.join(source, "./" + file), path.join(target, "./" + file));
+    });
+
+  }
+};
+
+// 移动文件或文件夹
+function moveSync(source, target) {
+
+  // 如果是文件，直接剪切即可
+  if (!fs.lstatSync(source).isDirectory()) {
+    fs.copyFileSync(source, target);
+    fs.unlinkSync(source);
+  } else {
+
+    // 读取子文件
+    const subFiles = fs.readdirSync(source);
+
+    // 如果文件夹不存在，创建
+    if (!fs.existsSync(target)) {
+      fs.mkdirSync(target, { recursive: true });
+    }
+
+    // 移动子文件或文件夹
+    subFiles.forEach(function (file) {
+      moveSync(path.join(source, "./" + file), path.join(target, "./" + file));
+    });
+
+    // 移动完子文件或文件夹以后（移动完毕也意味着子文件或文件夹被删除了）
+    fs.rmdirSync(source);
+  }
+}
+
+// 遍历当前文件或文件夹中所有文件
+function listFileSync(source, callback) {
+  // 文件夹 
+  if (fs.lstatSync(source).isDirectory()) {
+
+    // 读取子文件
+    const subFiles = fs.readdirSync(source);
+    subFiles.forEach(function (file) {
+      listFileSync(path.join(source, "./" + file), callback);
+    });
+  }
+
+  // 文件
+  else {
+    let folder = path.join(source, "../");
+
+    callback({
+      "name": source.replace(folder, ""),
+      "path": source,
+      "folder": folder
+    });
+  }
+}
+
+// 获取文件或文件夹的全路径
+function fullPathSync(pathString, contextPath) {
+  if (/^\//.test(pathString) || /^[A-Za-z]:\\/.test(pathString)) {
+    // 如果传递的就是全路径
+    return pathString;
+  }
+
+  if (arguments.length <= 1) {
+    // 默认把当前命令行作为上下文路径
+    contextPath = process.cwd();
+  }
+
+  // 拼全路径
+  return path.join(contextPath, pathString);
+}
+
+// 导出
+exports.deleteSync = deleteSync;
+exports.copySync = copySync;
+exports.moveSync = moveSync;
+exports.listFileSync = listFileSync;
+exports.fullPathSync = fullPathSync;

package/nodejs/core/image.js

@@ -0,0 +1,5 @@
+const fs = require('fs');
+
+exports.toBase64 = function (filepath) {
+    return "data:image/png;base64," + fs.readFileSync(filepath).toString('base64');
+};

package/nodejs/core/log.js

@@ -0,0 +1,82 @@
+// 日志
+exports.log = function (txt) {
+    console.log("\x1B[32m" + txt + "\x1B[39m");
+};
+
+// 警告
+exports.warn = function (txt) {
+    console.log("\x1B[33m" + txt + "\x1B[39m");
+};
+
+// 错误
+exports.error = function (txt) {
+    console.log("\x1B[35m" + txt + "\x1B[39m");
+};
+
+
+// 计算字符串长度的方法
+const stringwidth = function (str) {
+    return str.length;
+};
+
+// 预定义的常量
+const MOVE_LEFT = Buffer.from('1b5b3130303044', 'hex').toString();
+const MOVE_UP = Buffer.from('1b5b3141', 'hex').toString();
+const CLEAR_LINE = Buffer.from('1b5b304b', 'hex').toString();
+
+// 不换行打印
+const linelog = (function (stream) {
+
+    // 用来记录前置有多少行需要回退
+    let prevLineCount = 0;
+
+    // 返回实际同行打印的方法
+    return function (nextStr) {
+        let txt = "";
+
+        // 清除屏幕
+        for (let i = 0; i < prevLineCount; i++) {
+            txt += MOVE_LEFT + CLEAR_LINE + (i < prevLineCount - 1 ? MOVE_UP : '');
+        }
+
+        // 写入屏幕
+        stream.write(txt + nextStr);
+
+        // 重新计算需要回滚多少行
+        let prevLines = nextStr.split('\n');
+        prevLineCount = 0;
+        for (let i = 0; i < prevLines.length; i++) {
+            // 因为有时候文字过多，因此拿总长度除以一行长度得出真实的行数
+            prevLineCount += (Math.ceil(stringwidth(prevLines[i]) / stream.columns) || 1);
+        }
+
+    };
+})(process.stdout);
+
+exports.linelog = linelog;
+
+/**
+ * 进度打印
+ * 
+ * @param {number} percentum 进度0-100 
+ * @param {string} stream 说明文字,可选择
+ */
+exports.deeplog = function (percentum, stream) {
+
+    if (arguments.length <= 1) stream = "";
+
+    let txt = "",
+        i = 0;
+
+    // 补充已经有的进度
+    for (; i <= percentum && i <= 100; i += 5) {
+        txt += "█";
+    }
+
+    // 补充余下的空白
+    for (; i <= 100; i += 5) {
+        txt += "░";
+    }
+
+    linelog(percentum.toFixed(2) + "%[" + txt + "]" + stream);
+};

package/nodejs/core/network.js

@@ -0,0 +1,40 @@
+module.exports = function () {
+
+    let infomation = {
+        IPv4: [],
+        IPv6: []
+    };
+
+    let networks = require('os').networkInterfaces()
+
+    let IPv4Had = {}, IPv6Had = {}
+
+    for (let typeName in networks) {
+        let network = networks[typeName]
+        for (let index = 0; index < network.length; index++) {
+            if (network[index].mac != "00:00:00:00:00:00") {
+                if (network[index].family == 'IPv4' && network[index].address != '127.0.0.1') {
+                    if (!IPv4Had[network[index].mac]) {
+                        infomation.IPv4.push({
+                            address: network[index].address,
+                            mac: network[index].mac
+                        });
+
+                        IPv4Had[network[index].mac] = true
+                    }
+                } else if (network[index].family == 'IPv6' && network[index].address != '::1') {
+                    if (!IPv6Had[network[index].mac]) {
+                        infomation.IPv6.push({
+                            address: network[index].address,
+                            mac: network[index].mac
+                        });
+
+                        IPv6Had[network[index].mac] = true
+                    }
+                }
+            }
+        }
+    }
+
+    return infomation;
+};

package/nodejs/core/options.js

@@ -0,0 +1,49 @@
+/**
+ * 
+ * 命令行参数解析
+ * 
+ * @param {JSON} config 命令参数缩小到全写的映射
+ * @param {Array} argv 需要判断类型的值
+ * 
+ * @returns {JSON} 返回整理后的参数
+ * 
+ */
+module.exports = function (config, argv) {
+
+  let resultConfig = {
+    __terminal__: []
+  }, flag = null;
+  for (let i = 2; i < argv.length; i++) {
+
+    // 如果是新的配置
+    if (/^--[0-9a-zA-Z]+$/.test(argv[i]) || /^-[0-9a-zA-Z]$/.test(argv[i])) {
+      let key = argv[i];
+
+      // 如果是缩写，需要映射
+      if (key.length == 2) {
+        key = config[key];
+
+        // 如果是错误缩写
+        if (!key) {
+          flag = null;
+          continue;
+        }
+      }
+
+      flag = key.replace(/^--/, "");
+      resultConfig[flag] = [];
+    }
+
+    // 如果是普通的参数
+    else if (flag != null) {
+      resultConfig[flag].push(argv[i]);
+    }
+
+    else {
+      resultConfig.__terminal__.push(argv[i]);
+    }
+
+  }
+
+  return resultConfig;
+};

package/nodejs/core/remote.js

@@ -0,0 +1,60 @@
+const https = require('https');
+const http = require('http');
+
+exports.get = function (url, options = {}) {
+    return new Promise((resolve, reject) => {
+
+        let handler = /^https/.test(url) ? https : http;
+
+        handler.get(url, res => {
+            res.on('data', (data) => {
+                if (options.json) {
+                    resolve(JSON.parse(data.toString('utf8')));
+                } else {
+                    resolve(data);
+                }
+            });
+        }).on('error', (e) => {
+            reject(e);
+        });
+    });
+};
+
+exports.post = function (url, options = {}) {
+    return new Promise((resolve, reject) => {
+
+        let handler = /^https/.test(url) ? https : http;
+
+        let execArray = /https*:\/\/([^\/]+)(.+)?/.exec(url);
+        let hostport = execArray[1].split(":");
+
+        const req = handler.request({
+            hostname: hostport[0],
+            port: hostport[1] || 80,
+            path: execArray[2] || "/",
+            method: "POST",
+            headers: options.header || {}
+        }, (res) => {
+            res.setEncoding('utf8');
+
+            let data = "";
+            res.on('data', (chunk) => {
+                data += chunk;
+            });
+            res.on('end', () => {
+                if (options.json) {
+                    resolve(JSON.parse(data.toString('utf8')));
+                } else {
+                    resolve(data);
+                }
+            });
+        });
+
+        req.write(options.params || "{}");
+
+        req.on('error', (e) => {
+            reject(e);
+        });
+        req.end();
+    });
+};

package/nodejs/core/responseFileList.js

@@ -0,0 +1,28 @@
+const fs = require('fs');
+const path = require('path');
+
+const Template_404 = require('../data/404');
+
+// 读取当前路径下的文件，方便服务器404的时候导航
+module.exports = function (fullUrl) {
+
+  let files, content = fullUrl;
+  try {
+    files = fs.readdirSync(fullUrl);
+  } catch (e) {
+    try {
+      content = path.resolve(fullUrl, '../');
+      files = fs.readdirSync(content);
+    } catch (e) {
+      files = [];
+    }
+  }
+
+  let template = "<a href='../'>..</a>";
+  for (let i in files) {
+    let isDirectory = fs.lstatSync(path.join(content, files[i])).isDirectory();
+    template += "<a class='" + (isDirectory ? "folder" : "file") + "' href='./" + files[i] + (isDirectory ? "/" : "") + "'>" + files[i] + "</a>";
+  }
+
+  return Template_404(template);
+};

package/nodejs/core/server.js

@@ -0,0 +1,163 @@
+const http = require('http');
+const fs = require('fs');
+
+const mineTypes = require('../data/mime.types.js');
+const { log, warn, error } = require('./log.js');
+const responseFileList = require('./responseFileList.js');
+const path = require('path');
+
+const jsonfile = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json')));
+
+module.exports = function (config = {}) {
+
+    let port = config.port || 20000; // 端口号
+    let handler = typeof config.handler == 'function' ? config.handler : function () { return false; };
+    let suffixs = Array.isArray(config.suffix) ? config.suffix : [".html", ".htm", ".js", ".json", ".css"];
+
+    let proxy = [];
+    if (config.proxy) {
+        for (let item of config.proxy) {
+            let target = /(https*):\/\/([^/:]+):*(\d+)*(.*)/.exec(item.target) || [];
+            proxy.push({
+                test: item.test,
+                target: {
+                    protocol: target[1], // 使用的协议
+                    hostname: target[2], // 请求发送至的服务器的域名或 IP 地址
+                    port: target[3] || 80, // 端口号
+                    path: target[4] || "", // 路径前缀
+                }
+            });
+        }
+    }
+
+    let basePath = path.join(process.cwd(), config.basePath || "./"); // 服务器根路径
+
+    let index = 0;
+    let Server = http.createServer(function (request, response) {
+        try {
+            let requestData = "";
+
+            request.on('data', (chunk) => {
+                requestData += chunk;
+            });
+
+            request.on('end', () => {
+                let url = decodeURIComponent(request.url);
+
+                log("[" + index++ + "]" + url);
+
+                // 自定义拦截
+                if (handler.call({
+                    data: requestData,
+                    base: basePath
+                }, request, response)) return;
+
+                // proxy拦截
+                for (let item of proxy) {
+                    if (item.test.test(url)) {
+                        let _path = item.target.path + (url.replace(item.test, ""));
+
+                        warn("    ↳ [" + request.method + "] " + item.target.protocol + "://" + item.target.hostname + ":" + item.target.port + _path);
+
+                        // https://www.nodeapp.cn/http.html#http_http_request_options_callback
+                        const req = http.request({
+                            hostname: item.target.hostname,
+                            port: item.target.port,
+                            path: _path,
+                            method: request.method,
+                            headers: request.headers
+                        }, (res) => {
+                            res.setEncoding('utf8');
+
+                            let responseData = "";
+                            res.on('data', (chunk) => {
+                                responseData += chunk;
+                            });
+                            res.on('end', () => {
+                                let responseHeaders = res.headers;
+                                responseHeaders['proxy-server'] = "Powered by OIPage@" + jsonfile.version;
+                                responseHeaders['Access-Control-Allow-Origin'] = '*';
+                                response.writeHead(res.statusCode, responseHeaders);
+                                response.write(responseData);
+                                response.end();
+                            });
+                        });
+
+                        req.on('error', (e) => {
+                            error(`      转发的时候遇到问题: ${e.message}`);
+                            response.writeHead('500', {
+                                'Content-type': "text/plain;charset=utf-8",
+                                'Access-Control-Allow-Origin': '*',
+                                "proxy-server": "Powered by OIPage@" + jsonfile.version
+                            });
+                            response.write(e + "");
+                            response.end();
+                        });
+
+                        req.write(requestData);
+                        req.end();
+
+                        return;
+                    }
+                }
+
+                url = url.split("?")[0];
+
+                // 请求的文件路径
+                let filePath = path.join(basePath, url == "/" ? "index.html" : url.replace(/^\//, ""));
+
+                let dotName = /\./.test(filePath) ? filePath.match(/\.([^.]+)$/)[1] : "";
+
+                let is404 = true;
+                let doResponse = function (type, filePath) {
+                    response.writeHead(200, {
+                        'Content-type': (type || "text/plain") + ";charset=utf-8",
+                        'Access-Control-Allow-Origin': '*',
+                        'Server': "Powered by OIPage@" + jsonfile.version
+                    });
+                    response.write(fs.readFileSync(filePath));
+                    is404 = false;
+                };
+
+                // 文件类型
+                type = mineTypes[dotName];
+                if (fs.existsSync(filePath) && !fs.lstatSync(filePath).isDirectory()) {
+                    doResponse(type, filePath);
+                } else {
+                    for (let suffix of suffixs) {
+                        if (fs.existsSync(filePath + suffix) && !fs.lstatSync(filePath + suffix).isDirectory()) {
+                            type = mineTypes[suffix.replace(/^\./, "")];
+                            doResponse(type, filePath + suffix);
+                        }
+                    }
+                }
+
+                if (is404) {
+                    response.writeHead(404, {
+                        'Content-type': "text/html;charset=utf-8",
+                        'Access-Control-Allow-Origin': '*',
+                        'Server': "Powered by OIPage@" + jsonfile.version
+                    });
+                    response.write(responseFileList(filePath));
+                }
+
+                response.end();
+            });
+        } catch (e) {
+            error(e);
+
+            response.writeHead(500, {
+                'Content-type': "text/plain;charset=utf-8",
+                'Access-Control-Allow-Origin': '*',
+                'Server': "Powered by OIPage@" + jsonfile.version
+            });
+            response.write(e + "");
+
+            response.end();
+        }
+
+    });
+
+    Server.listen(port);
+    log('server running on port:' + port);
+};

package/nodejs/data/404.js

@@ -0,0 +1,52 @@
+const img_folder = require("./images/folder");
+const img_file = require("./images/file");
+
+module.exports = function (template) {
+    return `<!DOCTYPE html>
+    <html lang="zh-cn">
+    
+    <head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta http-equiv="X-UA-Compatible" content="ie=edge">
+    <title>404 Not Found</title>
+    <style>
+      body{
+          margin: 0px;
+          background-color:#fcfcfc;
+          display: flex;
+          flex-wrap:wrap;
+          padding:100px;
+      }
+      body>a{
+          text-decoration: none;
+          padding:10px;
+          color:#000000;
+          text-align:center;
+          width:100px;
+          background-repeat: no-repeat;
+          background-position: center 0px;
+          padding-top: 65px;
+          margin-top: 50px;
+          font-size:12px;
+      }
+      body>a:hover{
+          outline:1px solid #55b9e6;
+      }
+      body>a.folder{
+          background-image:url('${img_folder}');
+      }
+      body>a.file{
+          background-image:url('${img_file}');
+      }
+    </style>
+    </head>
+    
+    <body>
+    
+    ${template}
+    
+    </body>
+    
+    </html>`;
+};