npmapps 1.0.7 → 1.0.9

package/app/watchNginxConfig/node_modules/readdirp/index.js

@@ -0,0 +1,263 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReaddirpStream = exports.EntryTypes = void 0;
+exports.readdirp = readdirp;
+exports.readdirpPromise = readdirpPromise;
+const promises_1 = require("node:fs/promises");
+const node_stream_1 = require("node:stream");
+const node_path_1 = require("node:path");
+exports.EntryTypes = {
+    FILE_TYPE: 'files',
+    DIR_TYPE: 'directories',
+    FILE_DIR_TYPE: 'files_directories',
+    EVERYTHING_TYPE: 'all',
+};
+const defaultOptions = {
+    root: '.',
+    fileFilter: (_entryInfo) => true,
+    directoryFilter: (_entryInfo) => true,
+    type: exports.EntryTypes.FILE_TYPE,
+    lstat: false,
+    depth: 2147483648,
+    alwaysStat: false,
+    highWaterMark: 4096,
+};
+Object.freeze(defaultOptions);
+const RECURSIVE_ERROR_CODE = 'READDIRP_RECURSIVE_ERROR';
+const NORMAL_FLOW_ERRORS = new Set(['ENOENT', 'EPERM', 'EACCES', 'ELOOP', RECURSIVE_ERROR_CODE]);
+const ALL_TYPES = [
+    exports.EntryTypes.DIR_TYPE,
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+    exports.EntryTypes.FILE_TYPE,
+];
+const DIR_TYPES = new Set([
+    exports.EntryTypes.DIR_TYPE,
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+]);
+const FILE_TYPES = new Set([
+    exports.EntryTypes.EVERYTHING_TYPE,
+    exports.EntryTypes.FILE_DIR_TYPE,
+    exports.EntryTypes.FILE_TYPE,
+]);
+const isNormalFlowError = (error) => NORMAL_FLOW_ERRORS.has(error.code);
+const wantBigintFsStats = process.platform === 'win32';
+const emptyFn = (_entryInfo) => true;
+const normalizeFilter = (filter) => {
+    if (filter === undefined)
+        return emptyFn;
+    if (typeof filter === 'function')
+        return filter;
+    if (typeof filter === 'string') {
+        const fl = filter.trim();
+        return (entry) => entry.basename === fl;
+    }
+    if (Array.isArray(filter)) {
+        const trItems = filter.map((item) => item.trim());
+        return (entry) => trItems.some((f) => entry.basename === f);
+    }
+    return emptyFn;
+};
+/** Readable readdir stream, emitting new files as they're being listed. */
+class ReaddirpStream extends node_stream_1.Readable {
+    constructor(options = {}) {
+        super({
+            objectMode: true,
+            autoDestroy: true,
+            highWaterMark: options.highWaterMark,
+        });
+        const opts = { ...defaultOptions, ...options };
+        const { root, type } = opts;
+        this._fileFilter = normalizeFilter(opts.fileFilter);
+        this._directoryFilter = normalizeFilter(opts.directoryFilter);
+        const statMethod = opts.lstat ? promises_1.lstat : promises_1.stat;
+        // Use bigint stats if it's windows and stat() supports options (node 10+).
+        if (wantBigintFsStats) {
+            this._stat = (path) => statMethod(path, { bigint: true });
+        }
+        else {
+            this._stat = statMethod;
+        }
+        this._maxDepth = opts.depth ?? defaultOptions.depth;
+        this._wantsDir = type ? DIR_TYPES.has(type) : false;
+        this._wantsFile = type ? FILE_TYPES.has(type) : false;
+        this._wantsEverything = type === exports.EntryTypes.EVERYTHING_TYPE;
+        this._root = (0, node_path_1.resolve)(root);
+        this._isDirent = !opts.alwaysStat;
+        this._statsProp = this._isDirent ? 'dirent' : 'stats';
+        this._rdOptions = { encoding: 'utf8', withFileTypes: this._isDirent };
+        // Launch stream with one parent, the root dir.
+        this.parents = [this._exploreDir(root, 1)];
+        this.reading = false;
+        this.parent = undefined;
+    }
+    async _read(batch) {
+        if (this.reading)
+            return;
+        this.reading = true;
+        try {
+            while (!this.destroyed && batch > 0) {
+                const par = this.parent;
+                const fil = par && par.files;
+                if (fil && fil.length > 0) {
+                    const { path, depth } = par;
+                    const slice = fil.splice(0, batch).map((dirent) => this._formatEntry(dirent, path));
+                    const awaited = await Promise.all(slice);
+                    for (const entry of awaited) {
+                        if (!entry)
+                            continue;
+                        if (this.destroyed)
+                            return;
+                        const entryType = await this._getEntryType(entry);
+                        if (entryType === 'directory' && this._directoryFilter(entry)) {
+                            if (depth <= this._maxDepth) {
+                                this.parents.push(this._exploreDir(entry.fullPath, depth + 1));
+                            }
+                            if (this._wantsDir) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                        else if ((entryType === 'file' || this._includeAsFile(entry)) &&
+                            this._fileFilter(entry)) {
+                            if (this._wantsFile) {
+                                this.push(entry);
+                                batch--;
+                            }
+                        }
+                    }
+                }
+                else {
+                    const parent = this.parents.pop();
+                    if (!parent) {
+                        this.push(null);
+                        break;
+                    }
+                    this.parent = await parent;
+                    if (this.destroyed)
+                        return;
+                }
+            }
+        }
+        catch (error) {
+            this.destroy(error);
+        }
+        finally {
+            this.reading = false;
+        }
+    }
+    async _exploreDir(path, depth) {
+        let files;
+        try {
+            files = await (0, promises_1.readdir)(path, this._rdOptions);
+        }
+        catch (error) {
+            this._onError(error);
+        }
+        return { files, depth, path };
+    }
+    async _formatEntry(dirent, path) {
+        let entry;
+        const basename = this._isDirent ? dirent.name : dirent;
+        try {
+            const fullPath = (0, node_path_1.resolve)((0, node_path_1.join)(path, basename));
+            entry = { path: (0, node_path_1.relative)(this._root, fullPath), fullPath, basename };
+            entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
+        }
+        catch (err) {
+            this._onError(err);
+            return;
+        }
+        return entry;
+    }
+    _onError(err) {
+        if (isNormalFlowError(err) && !this.destroyed) {
+            this.emit('warn', err);
+        }
+        else {
+            this.destroy(err);
+        }
+    }
+    async _getEntryType(entry) {
+        // entry may be undefined, because a warning or an error were emitted
+        // and the statsProp is undefined
+        if (!entry && this._statsProp in entry) {
+            return '';
+        }
+        const stats = entry[this._statsProp];
+        if (stats.isFile())
+            return 'file';
+        if (stats.isDirectory())
+            return 'directory';
+        if (stats && stats.isSymbolicLink()) {
+            const full = entry.fullPath;
+            try {
+                const entryRealPath = await (0, promises_1.realpath)(full);
+                const entryRealPathStats = await (0, promises_1.lstat)(entryRealPath);
+                if (entryRealPathStats.isFile()) {
+                    return 'file';
+                }
+                if (entryRealPathStats.isDirectory()) {
+                    const len = entryRealPath.length;
+                    if (full.startsWith(entryRealPath) && full.substr(len, 1) === node_path_1.sep) {
+                        const recursiveError = new Error(`Circular symlink detected: "${full}" points to "${entryRealPath}"`);
+                        // @ts-ignore
+                        recursiveError.code = RECURSIVE_ERROR_CODE;
+                        return this._onError(recursiveError);
+                    }
+                    return 'directory';
+                }
+            }
+            catch (error) {
+                this._onError(error);
+                return '';
+            }
+        }
+    }
+    _includeAsFile(entry) {
+        const stats = entry && entry[this._statsProp];
+        return stats && this._wantsEverything && !stats.isDirectory();
+    }
+}
+exports.ReaddirpStream = ReaddirpStream;
+/**
+ * Streaming version: Reads all files and directories in given root recursively.
+ * Consumes ~constant small amount of RAM.
+ * @param root Root directory
+ * @param options Options to specify root (start directory), filters and recursion depth
+ */
+function readdirp(root, options = {}) {
+    // @ts-ignore
+    let type = options.entryType || options.type;
+    if (type === 'both')
+        type = exports.EntryTypes.FILE_DIR_TYPE; // backwards-compatibility
+    if (type)
+        options.type = type;
+    if (!root) {
+        throw new Error('readdirp: root argument is required. Usage: readdirp(root, options)');
+    }
+    else if (typeof root !== 'string') {
+        throw new TypeError('readdirp: root argument must be a string. Usage: readdirp(root, options)');
+    }
+    else if (type && !ALL_TYPES.includes(type)) {
+        throw new Error(`readdirp: Invalid type passed. Use one of ${ALL_TYPES.join(', ')}`);
+    }
+    options.root = root;
+    return new ReaddirpStream(options);
+}
+/**
+ * Promise version: Reads all files and directories in given root recursively.
+ * Compared to streaming version, will consume a lot of RAM e.g. when 1 million files are listed.
+ * @returns array of paths and their entry infos
+ */
+function readdirpPromise(root, options = {}) {
+    return new Promise((resolve, reject) => {
+        const files = [];
+        readdirp(root, options)
+            .on('data', (entry) => files.push(entry))
+            .on('end', () => resolve(files))
+            .on('error', (error) => reject(error));
+    });
+}
+exports.default = readdirp;

package/app/watchNginxConfig/node_modules/readdirp/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "readdirp",
+  "description": "Recursive version of fs.readdir with small RAM & CPU footprint.",
+  "version": "4.1.2",
+  "homepage": "https://github.com/paulmillr/readdirp",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/paulmillr/readdirp.git"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/paulmillr/readdirp/issues"
+  },
+  "author": "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+  "contributors": [
+    "Thorsten Lorenz <thlorenz@gmx.de> (thlorenz.com)",
+    "Paul Miller (https://paulmillr.com)"
+  ],
+  "engines": {
+    "node": ">= 14.18.0"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "index.d.ts.map",
+    "index.js.map",
+    "esm"
+  ],
+  "main": "./index.js",
+  "module": "./esm/index.js",
+  "types": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./index.js"
+    }
+  },
+  "sideEffects": false,
+  "keywords": [
+    "recursive",
+    "fs",
+    "stream",
+    "streams",
+    "readdir",
+    "filesystem",
+    "find",
+    "filter"
+  ],
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "lint": "prettier --check index.ts test/index.test.js",
+    "format": "prettier --write index.ts test/index.test.js",
+    "test": "node test/index.test.js",
+    "test:coverage": "c8 node test/index.test.js"
+  },
+  "devDependencies": {
+    "@paulmillr/jsbt": "0.3.1",
+    "@types/node": "20.14.8",
+    "c8": "10.1.3",
+    "chai": "4.3.4",
+    "chai-subset": "1.6.0",
+    "micro-should": "0.5.0",
+    "prettier": "3.1.1",
+    "typescript": "5.5.2"
+  },
+  "funding": {
+    "type": "individual",
+    "url": "https://paulmillr.com/funding/"
+  }
+}

package/app/watchNginxConfig/package-lock.json

@@ -0,0 +1,40 @@
+{
+  "name": "node",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "chokidar": "^4.0.3"
+      }
+    },
+    "node_modules/chokidar": {
+      "version": "4.0.3",
+      "resolved": "https://registry.npmjs.org/chokidar/-/chokidar-4.0.3.tgz",
+      "integrity": "sha512-Qgzu8kfBvo+cA4962jnP1KkS6Dop5NS6g7R5LFYJr4b8Ub94PPQXUksCw9PvXoeXPRRddRNC5C1JQUR2SMGtnA==",
+      "license": "MIT",
+      "dependencies": {
+        "readdirp": "^4.0.1"
+      },
+      "engines": {
+        "node": ">= 14.16.0"
+      },
+      "funding": {
+        "url": "https://paulmillr.com/funding/"
+      }
+    },
+    "node_modules/readdirp": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/readdirp/-/readdirp-4.1.2.tgz",
+      "integrity": "sha512-GDhwkLfywWL2s6vEjyhri+eXmfH6j1L7JE27WhqLeYzoh/A3DBaYGEj2H/HFZCn/kMfim73FXxEJTw06WtxQwg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 14.18.0"
+      },
+      "funding": {
+        "type": "individual",
+        "url": "https://paulmillr.com/funding/"
+      }
+    }
+  }
+}

package/app/watchNginxConfig/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "chokidar": "^4.0.3"
+  }
+}

package/app/watchNginxConfig/start_nginx_watcher.bat

@@ -0,0 +1,4 @@
+@echo off
+cd /d c:\Users\w1768\Documents\wk\web\node
+start cmd /k "node watchNginxConfig.js"
+pause

package/app/watchNginxConfig/watchNginxConfig.js

@@ -0,0 +1,104 @@
+const chokidar = require('chokidar');
+const { exec } = require('child_process');
+
+// Nginx配置文件目录，根据实际情况修改
+const NGINX_CONFIG_DIR = 'C:/nginx/conf';
+// Nginx可执行文件路径，根据实际情况修改
+const NGINX_EXEC_PATH = 'C:/nginx/nginx.exe';
+
+// 检查Nginx是否正在运行
+function checkNginxStatus() {
+  return new Promise((resolve, reject) => {
+    exec('tasklist /FI "IMAGENAME eq nginx.exe"', (error, stdout) => {
+      if (error) reject(error);
+      resolve(stdout.includes('nginx.exe'));
+    });
+  });
+}
+
+// 启动Nginx
+function startNginx() {
+  return new Promise((resolve, reject) => {
+    console.log('正在启动Nginx...');
+    exec(`"${NGINX_EXEC_PATH}"`, (error, stdout, stderr) => {
+      if (error) {
+        reject(`启动失败: ${error.message}`);
+        return;
+      }
+      if (stderr) {
+        reject(`Nginx错误: ${stderr}`);
+        return;
+      }
+      console.log('Nginx启动成功');
+      resolve();
+    });
+  });
+}
+
+// 创建文件监听器
+function startWatcher() {
+  const watcher = chokidar.watch(NGINX_CONFIG_DIR, {
+    ignored: /(^|\/\.)\../, // 忽略点文件
+    persistent: true,
+    ignoreInitial: true
+  });
+
+  console.log(`正在监听Nginx配置文件变化: ${NGINX_CONFIG_DIR}`);
+
+  watcher
+    .on('all', (event, path) => {
+      console.log(`检测到配置文件变化: ${path} (事件: ${event})`);
+      reloadNginxConfig();
+    })
+    .on('error', error => console.error('监听错误:', error));
+
+  return watcher;
+}
+
+// 初始化流程
+async function init() {
+  try {
+    const isRunning = await checkNginxStatus();
+    if (!isRunning) {
+      await startNginx();
+    } else {
+      console.log('Nginx已运行');
+    }
+    const watcher = startWatcher();
+
+    // 处理程序退出
+    process.on('SIGINT', () => {
+      console.log('正在关闭监听器...');
+      watcher.close().then(() => process.exit(0));
+    });
+  } catch (error) {
+    console.error('初始化失败:', error);
+    process.exit(1);
+  }
+}
+
+// 启动应用
+init();
+
+// 重新加载Nginx配置
+function reloadNginxConfig() {
+  console.log('正在重新加载Nginx配置...');
+  exec(`"${NGINX_EXEC_PATH}" -s reload`, (error, stdout, stderr) => {
+    if (error) {
+      console.error(`重新加载失败: ${error.message}`);
+      return;
+    }
+    if (stderr) {
+      console.error(`Nginx错误输出: ${stderr}`);
+      return;
+    }
+    console.log('Nginx配置重新加载成功!');
+  });
+}
+
+// 处理程序退出
+process.on('SIGINT', async () => {
+  console.log('正在关闭监听器...');
+  await watcher.close();
+  process.exit(0);
+}); 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "npmapps",
-    "version": "1.0.7",
+    "version": "1.0.9",
     "main": "index.js",
     "scripts": {
       "test": "echo \"Error: no test specified\" && exit 1"

package/app/components/attendanceCycle/index.vue

@@ -1,131 +0,0 @@
-<template>
-  <div class="attendanceCycle" v-loading="loading">
-    <div class="header">
-      <div class="left">
-        <el-button size="mini" type="primary" @click="onSave">选择</el-button>
-      </div>
-      <div class="right">
-        <el-select
-          size="mini"
-          v-model="year"
-          placeholder="请选择"
-          @change="yearChange"
-        >
-          <el-option
-            v-for="item in options"
-            :key="item.yearId"
-            :label="item.yearName"
-            :value="item.yearId"
-          >
-          </el-option>
-        </el-select>
-      </div>
-    </div>
-    <el-table
-      size="mini"
-      :data="tableData"
-      style="width: 100%"
-      border
-      @row-click="handleRowClick"
-    >
-      <!-- 单选框列 -->
-      <el-table-column width="50">
-        <template slot-scope="scope">
-          <el-radio
-            :value="currentRow.monthId"
-            :label="scope.row.monthId"
-          >&nbsp;</el-radio>
-        </template>
-      </el-table-column>
-      <el-table-column prop="monthName" label="名称"></el-table-column>
-      <el-table-column prop="monthName" label="开始日期"></el-table-column>
-      <el-table-column prop="monthName" label="结束日期"></el-table-column>
-    </el-table>
-  </div>
-</template>
-
-<script>
-import {
-  getOpenAttendanceCycleMonthListApi,
-  getOpenAttendanceCycleYearListApi,
-} from "../../employeeSchedulingManagement/data.js";
-
-export default {
-  // 考勤周期
-  props: {
-    close: {
-      type: Function,
-      default: () => {},
-    },
-    setData:{
-        type: Function,
-        default: () => {},
-    },
-  },
-
-  data() {
-    return {
-      loading: false,
-      tableData: [],
-      year: "2025",
-      options: [],
-      currentRow: {
-        monthId: "",
-      }, // 当前选中的行
-    };
-  },
-  mounted() {
-    this.loading = false;
-    this.getTableData();
-    this.getYearList();
-  },
-  methods: {
-    getTableData() {
-      this.loading = true;
-      getOpenAttendanceCycleMonthListApi(this.year).then((res) => {
-        this.tableData = res;
-        console.log(res, "res");
-        this.loading = false;
-      });
-    },
-    getYearList() {
-      getOpenAttendanceCycleYearListApi().then((res) => {
-        this.options = res;
-      });
-    },
-    yearChange() {
-      this.getTableData();
-    },
-    handleRowClick(row) {
-      this.currentRow = row; // 点击行时更新选中状态
-    },
-    onSave() {
-        if (this.currentRow.monthId === "") {
-            return this.$message.error("请选择");
-        }
-      this.close();
-      this.setData(this.currentRow);
-    },
-
-  },
-};
-</script>
-
-<style lang="less" scoped>
-.attendanceCycle {
-  .header {
-    display: flex;
-    justify-content: space-between;
-    align-items: center;
-    margin-bottom: 10px;
-    .left {
-      display: flex;
-      align-items: center;
-    }
-    .right {
-      display: flex;
-      align-items: center;
-    }
-  }
-}
-</style>