前端 uni-app 重写: 9页面 H5

This commit is contained in:
zhiqui
2026-11-15 15:09:37 +08:00
parent 513b53672e
commit ea7c2529e9
24104 changed files with 3667749 additions and 0 deletions
+21
View File
@@ -0,0 +1,21 @@
MIT License
Copyright (c) Meta Platforms, Inc. and its affiliates.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
+34
View File
@@ -0,0 +1,34 @@
# fb-watchman
`fb-watchman` is a filesystem watcher that uses the
[Watchman](https://facebook.github.io/watchman/) file watching service from
Facebook.
Watchman provides file change notification services using very
efficient recursive watches and also allows more advanced change matching and
filesystem tree querying operations using
[a powerful expression syntax](https://facebook.github.io/watchman/docs/file-query.html#expressions).
## Install
You should [install Watchman](
https://facebook.github.io/watchman/docs/install.html) to make the most of this
module.
Then simply:
```
$ npm install fb-watchman
```
## Key Concepts
- Watchman recursively watches directories.
- Each watched directory is called a `root`.
- You must initiate a `watch` on a `root` using the `watch-project` command prior to subscribing to changes
- Rather than separately watching many sibling directories, `watch-project` consolidates and re-uses existing watches relative to a project root (the location of your `.watchmanconfig` or source control repository root)
- change notifications are relative to the project root
## How do I use it?
[Read the NodeJS watchman documentation](https://facebook.github.io/watchman/docs/nodejs.html)
+327
View File
@@ -0,0 +1,327 @@
/**
* Copyright (c) Meta Platforms, Inc. and affiliates.
*
* This source code is licensed under the MIT license found in the
* LICENSE file in the root directory of this source tree.
*/
'use strict';
var net = require('net');
var EE = require('events').EventEmitter;
var util = require('util');
var childProcess = require('child_process');
var bser = require('bser');
// We'll emit the responses to these when they get sent down to us
var unilateralTags = ['subscription', 'log'];
/**
* @param options An object with the following optional keys:
* * 'watchmanBinaryPath' (string) Absolute path to the watchman binary.
* If not provided, the Client locates the binary using the PATH specified
* by the node child_process's default env.
*/
function Client(options) {
var self = this;
EE.call(this);
this.watchmanBinaryPath = 'watchman';
if (options && options.watchmanBinaryPath) {
this.watchmanBinaryPath = options.watchmanBinaryPath.trim();
};
this.commands = [];
}
util.inherits(Client, EE);
module.exports.Client = Client;
// Try to send the next queued command, if any
Client.prototype.sendNextCommand = function() {
if (this.currentCommand) {
// There's a command pending response, don't send this new one yet
return;
}
this.currentCommand = this.commands.shift();
if (!this.currentCommand) {
// No further commands are queued
return;
}
this.socket.write(bser.dumpToBuffer(this.currentCommand.cmd));
}
Client.prototype.cancelCommands = function(why) {
var error = new Error(why);
// Steal all pending commands before we start cancellation, in
// case something decides to schedule more commands
var cmds = this.commands;
this.commands = [];
if (this.currentCommand) {
cmds.unshift(this.currentCommand);
this.currentCommand = null;
}
// Synthesize an error condition for any commands that were queued
cmds.forEach(function(cmd) {
cmd.cb(error);
});
}
Client.prototype.connect = function() {
var self = this;
function makeSock(sockname) {
// bunser will decode the watchman BSER protocol for us
self.bunser = new bser.BunserBuf();
// For each decoded line:
self.bunser.on('value', function(obj) {
// Figure out if this is a unliteral response or if it is the
// response portion of a request-response sequence. At the time
// of writing, there are only two possible unilateral responses.
var unilateral = false;
for (var i = 0; i < unilateralTags.length; i++) {
var tag = unilateralTags[i];
if (tag in obj) {
unilateral = tag;
}
}
if (unilateral) {
self.emit(unilateral, obj);
} else if (self.currentCommand) {
var cmd = self.currentCommand;
self.currentCommand = null;
if ('error' in obj) {
var error = new Error(obj.error);
error.watchmanResponse = obj;
cmd.cb(error);
} else {
cmd.cb(null, obj);
}
}
// See if we can dispatch the next queued command, if any
self.sendNextCommand();
});
self.bunser.on('error', function(err) {
self.emit('error', err);
});
self.socket = net.createConnection(sockname);
self.socket.on('connect', function() {
self.connecting = false;
self.emit('connect');
self.sendNextCommand();
});
self.socket.on('error', function(err) {
self.connecting = false;
self.emit('error', err);
});
self.socket.on('data', function(buf) {
if (self.bunser) {
self.bunser.append(buf);
}
});
self.socket.on('end', function() {
self.socket = null;
self.bunser = null;
self.cancelCommands('The watchman connection was closed');
self.emit('end');
});
}
// triggers will export the sock path to the environment.
// If we're invoked in such a way, we can simply pick up the
// definition from the environment and avoid having to fork off
// a process to figure it out
if (process.env.WATCHMAN_SOCK) {
makeSock(process.env.WATCHMAN_SOCK);
return;
}
// We need to ask the client binary where to find it.
// This will cause the service to start for us if it isn't
// already running.
var args = ['--no-pretty', 'get-sockname'];
// We use the more elaborate spawn rather than exec because there
// are some error cases on Windows where process spawning can hang.
// It is desirable to pipe stderr directly to stderr live so that
// we can discover the problem.
var proc = null;
var spawnFailed = false;
function spawnError(error) {
if (spawnFailed) {
// For ENOENT, proc 'close' will also trigger with a negative code,
// let's suppress that second error.
return;
}
spawnFailed = true;
if (error.code === 'EACCES' || error.errno === 'EACCES') {
error.message = 'The Watchman CLI is installed but cannot ' +
'be spawned because of a permission problem';
} else if (error.code === 'ENOENT' || error.errno === 'ENOENT') {
error.message = 'Watchman was not found in PATH. See ' +
'https://facebook.github.io/watchman/docs/install.html ' +
'for installation instructions';
}
console.error('Watchman: ', error.message);
self.emit('error', error);
}
try {
proc = childProcess.spawn(this.watchmanBinaryPath, args, {
stdio: ['ignore', 'pipe', 'pipe'],
windowsHide: true
});
} catch (error) {
spawnError(error);
return;
}
var stdout = [];
var stderr = [];
proc.stdout.on('data', function(data) {
stdout.push(data);
});
proc.stderr.on('data', function(data) {
data = data.toString('utf8');
stderr.push(data);
console.error(data);
});
proc.on('error', function(error) {
spawnError(error);
});
proc.on('close', function (code, signal) {
if (code !== 0) {
spawnError(new Error(
self.watchmanBinaryPath + ' ' + args.join(' ') +
' returned with exit code=' + code + ', signal=' +
signal + ', stderr= ' + stderr.join('')));
return;
}
try {
var obj = JSON.parse(stdout.join(''));
if ('error' in obj) {
var error = new Error(obj.error);
error.watchmanResponse = obj;
self.emit('error', error);
return;
}
makeSock(obj.sockname);
} catch (e) {
self.emit('error', e);
}
});
}
Client.prototype.command = function(args, done) {
done = done || function() {};
// Queue up the command
this.commands.push({cmd: args, cb: done});
// Establish a connection if we don't already have one
if (!this.socket) {
if (!this.connecting) {
this.connecting = true;
this.connect();
return;
}
return;
}
// If we're already connected and idle, try sending the command immediately
this.sendNextCommand();
}
var cap_versions = {
"cmd-watch-del-all": "3.1.1",
"cmd-watch-project": "3.1",
"relative_root": "3.3",
"term-dirname": "3.1",
"term-idirname": "3.1",
"wildmatch": "3.7",
}
// Compares a vs b, returns < 0 if a < b, > 0 if b > b, 0 if a == b
function vers_compare(a, b) {
a = a.split('.');
b = b.split('.');
for (var i = 0; i < 3; i++) {
var d = parseInt(a[i] || '0') - parseInt(b[i] || '0');
if (d != 0) {
return d;
}
}
return 0; // Equal
}
function have_cap(vers, name) {
if (name in cap_versions) {
return vers_compare(vers, cap_versions[name]) >= 0;
}
return false;
}
// This is a helper that we expose for testing purposes
Client.prototype._synthesizeCapabilityCheck = function(
resp, optional, required) {
resp.capabilities = {}
var version = resp.version;
optional.forEach(function (name) {
resp.capabilities[name] = have_cap(version, name);
});
required.forEach(function (name) {
var have = have_cap(version, name);
resp.capabilities[name] = have;
if (!have) {
resp.error = 'client required capability `' + name +
'` is not supported by this server';
}
});
return resp;
}
Client.prototype.capabilityCheck = function(caps, done) {
var optional = caps.optional || [];
var required = caps.required || [];
var self = this;
this.command(['version', {
optional: optional,
required: required
}], function (error, resp) {
if (error) {
done(error);
return;
}
if (!('capabilities' in resp)) {
// Server doesn't support capabilities, so we need to
// synthesize the results based on the version
resp = self._synthesizeCapabilityCheck(resp, optional, required);
if (resp.error) {
error = new Error(resp.error);
error.watchmanResponse = resp;
done(error);
return;
}
}
done(null, resp);
});
}
// Close the connection to the service
Client.prototype.end = function() {
this.cancelCommands('The client was ended');
if (this.socket) {
this.socket.end();
this.socket = null;
}
this.bunser = null;
}
+35
View File
@@ -0,0 +1,35 @@
{
"name": "fb-watchman",
"version": "2.0.4",
"description": "Bindings for the Watchman file watching service",
"main": "index.js",
"repository": {
"type": "git",
"url": "git@github.com:facebook/watchman.git"
},
"keywords": [
"facebook",
"watchman",
"file",
"watch",
"watcher",
"watching",
"fs.watch",
"fswatcher",
"fs",
"glob",
"utility"
],
"author": "Wez Furlong <wez@fb.com> (http://wezfurlong.org)",
"license": "MIT",
"bugs": {
"url": "https://github.com/facebook/watchman/issues"
},
"homepage": "https://facebook.github.io/watchman/",
"files": [
"index.js"
],
"dependencies": {
"bser": "2.1.2"
}
}