Simple feedback server
This commit is contained in:
388
feedback-server/externs/send/SendStream.hx
Normal file
388
feedback-server/externs/send/SendStream.hx
Normal file
@@ -0,0 +1,388 @@
|
||||
package send;
|
||||
|
||||
typedef SendStream = {
|
||||
function etag(val:Bool):SendStream;
|
||||
function hidden(val:Bool):SendStream;
|
||||
function index(paths:ts.AnyOf2<String, Array<String>>):SendStream;
|
||||
function root(paths:String):SendStream;
|
||||
function from(paths:String):SendStream;
|
||||
function maxage(maxAge:ts.AnyOf2<String, Float>):SendStream;
|
||||
/**
|
||||
Emit error with `status`.
|
||||
**/
|
||||
function error(status:Float, ?error:js.lib.Error):Void;
|
||||
/**
|
||||
Check if the pathname ends with "/".
|
||||
**/
|
||||
function hasTrailingSlash():Bool;
|
||||
/**
|
||||
Check if this is a conditional GET request.
|
||||
**/
|
||||
function isConditionalGET():Bool;
|
||||
/**
|
||||
Strip content-* header fields.
|
||||
**/
|
||||
function removeContentHeaderFields():Void;
|
||||
/**
|
||||
Respond with 304 not modified.
|
||||
**/
|
||||
function notModified():Void;
|
||||
/**
|
||||
Raise error that headers already sent.
|
||||
**/
|
||||
function headersAlreadySent():Void;
|
||||
/**
|
||||
Check if the request is cacheable, aka responded with 2xx or 304 (see RFC 2616 section 14.2{5,6}).
|
||||
**/
|
||||
function isCachable():Bool;
|
||||
/**
|
||||
Handle stat() error.
|
||||
**/
|
||||
function onStatError(error:js.lib.Error):Void;
|
||||
/**
|
||||
Check if the cache is fresh.
|
||||
**/
|
||||
function isFresh():Bool;
|
||||
/**
|
||||
Check if the range is fresh.
|
||||
**/
|
||||
function isRangeFresh():Bool;
|
||||
/**
|
||||
Redirect to path.
|
||||
**/
|
||||
function redirect(path:String):Void;
|
||||
/**
|
||||
Pipe to `res`.
|
||||
**/
|
||||
function pipe<T>(res:T):T;
|
||||
/**
|
||||
Transfer `path`.
|
||||
**/
|
||||
function send(path:String, ?stat:node.fs.Stats):Void;
|
||||
/**
|
||||
Transfer file for `path`.
|
||||
**/
|
||||
function sendFile(path:String):Void;
|
||||
/**
|
||||
Transfer index for `path`.
|
||||
**/
|
||||
function sendIndex(path:String):Void;
|
||||
/**
|
||||
Transfer index for `path`.
|
||||
**/
|
||||
function stream(path:String, ?options:{ }):Void;
|
||||
/**
|
||||
Set content-type based on `path` if it hasn't been explicitly set.
|
||||
**/
|
||||
function type(path:String):Void;
|
||||
/**
|
||||
Set response header fields, most fields may be pre-defined.
|
||||
**/
|
||||
function setHeader(path:String, stat:node.fs.Stats):Void;
|
||||
function compose<T>(stream:ts.AnyOf4<SendStream, Iterable<T>, js.lib.AsyncIterable<T>, T>, ?options:{ var signal : js.html.AbortSignal; }):T;
|
||||
/**
|
||||
Alias for `emitter.on(eventName, listener)`.
|
||||
**/
|
||||
function addListener(eventName:ts.AnyOf2<String, js.lib.Symbol>, listener:(args:haxe.extern.Rest<Dynamic>) -> Void):SendStream;
|
||||
/**
|
||||
Adds the `listener` function to the end of the listeners array for the
|
||||
event named `eventName`. No checks are made to see if the `listener` has
|
||||
already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
|
||||
times.
|
||||
|
||||
```js
|
||||
server.on('connection', (stream) => {
|
||||
console.log('someone connected!');
|
||||
});
|
||||
```
|
||||
|
||||
Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
|
||||
By default, event listeners are invoked in the order they are added. The`emitter.prependListener()` method can be used as an alternative to add the
|
||||
event listener to the beginning of the listeners array.
|
||||
|
||||
```js
|
||||
import { EventEmitter } from 'node:events';
|
||||
const myEE = new EventEmitter();
|
||||
myEE.on('foo', () => console.log('a'));
|
||||
myEE.prependListener('foo', () => console.log('b'));
|
||||
myEE.emit('foo');
|
||||
// Prints:
|
||||
// b
|
||||
// a
|
||||
```
|
||||
**/
|
||||
function on(eventName:ts.AnyOf2<String, js.lib.Symbol>, listener:(args:haxe.extern.Rest<Dynamic>) -> Void):SendStream;
|
||||
/**
|
||||
Adds a **one-time**`listener` function for the event named `eventName`. The
|
||||
next time `eventName` is triggered, this listener is removed and then invoked.
|
||||
|
||||
```js
|
||||
server.once('connection', (stream) => {
|
||||
console.log('Ah, we have our first user!');
|
||||
});
|
||||
```
|
||||
|
||||
Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
|
||||
By default, event listeners are invoked in the order they are added. The`emitter.prependOnceListener()` method can be used as an alternative to add the
|
||||
event listener to the beginning of the listeners array.
|
||||
|
||||
```js
|
||||
import { EventEmitter } from 'node:events';
|
||||
const myEE = new EventEmitter();
|
||||
myEE.once('foo', () => console.log('a'));
|
||||
myEE.prependOnceListener('foo', () => console.log('b'));
|
||||
myEE.emit('foo');
|
||||
// Prints:
|
||||
// b
|
||||
// a
|
||||
```
|
||||
**/
|
||||
function once(eventName:ts.AnyOf2<String, js.lib.Symbol>, listener:(args:haxe.extern.Rest<Dynamic>) -> Void):SendStream;
|
||||
/**
|
||||
Removes the specified `listener` from the listener array for the event named`eventName`.
|
||||
|
||||
```js
|
||||
const callback = (stream) => {
|
||||
console.log('someone connected!');
|
||||
};
|
||||
server.on('connection', callback);
|
||||
// ...
|
||||
server.removeListener('connection', callback);
|
||||
```
|
||||
|
||||
`removeListener()` will remove, at most, one instance of a listener from the
|
||||
listener array. If any single listener has been added multiple times to the
|
||||
listener array for the specified `eventName`, then `removeListener()` must be
|
||||
called multiple times to remove each instance.
|
||||
|
||||
Once an event is emitted, all listeners attached to it at the
|
||||
time of emitting are called in order. This implies that any`removeListener()` or `removeAllListeners()` calls _after_ emitting and _before_ the last listener finishes execution
|
||||
will not remove them from`emit()` in progress. Subsequent events behave as expected.
|
||||
|
||||
```js
|
||||
import { EventEmitter } from 'node:events';
|
||||
class MyEmitter extends EventEmitter {}
|
||||
const myEmitter = new MyEmitter();
|
||||
|
||||
const callbackA = () => {
|
||||
console.log('A');
|
||||
myEmitter.removeListener('event', callbackB);
|
||||
};
|
||||
|
||||
const callbackB = () => {
|
||||
console.log('B');
|
||||
};
|
||||
|
||||
myEmitter.on('event', callbackA);
|
||||
|
||||
myEmitter.on('event', callbackB);
|
||||
|
||||
// callbackA removes listener callbackB but it will still be called.
|
||||
// Internal listener array at time of emit [callbackA, callbackB]
|
||||
myEmitter.emit('event');
|
||||
// Prints:
|
||||
// A
|
||||
// B
|
||||
|
||||
// callbackB is now removed.
|
||||
// Internal listener array [callbackA]
|
||||
myEmitter.emit('event');
|
||||
// Prints:
|
||||
// A
|
||||
```
|
||||
|
||||
Because listeners are managed using an internal array, calling this will
|
||||
change the position indices of any listener registered _after_ the listener
|
||||
being removed. This will not impact the order in which listeners are called,
|
||||
but it means that any copies of the listener array as returned by
|
||||
the `emitter.listeners()` method will need to be recreated.
|
||||
|
||||
When a single function has been added as a handler multiple times for a single
|
||||
event (as in the example below), `removeListener()` will remove the most
|
||||
recently added instance. In the example the `once('ping')`listener is removed:
|
||||
|
||||
```js
|
||||
import { EventEmitter } from 'node:events';
|
||||
const ee = new EventEmitter();
|
||||
|
||||
function pong() {
|
||||
console.log('pong');
|
||||
}
|
||||
|
||||
ee.on('ping', pong);
|
||||
ee.once('ping', pong);
|
||||
ee.removeListener('ping', pong);
|
||||
|
||||
ee.emit('ping');
|
||||
ee.emit('ping');
|
||||
```
|
||||
|
||||
Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
**/
|
||||
function removeListener(eventName:ts.AnyOf2<String, js.lib.Symbol>, listener:(args:haxe.extern.Rest<Dynamic>) -> Void):SendStream;
|
||||
/**
|
||||
Alias for `emitter.removeListener()`.
|
||||
**/
|
||||
function off(eventName:ts.AnyOf2<String, js.lib.Symbol>, listener:(args:haxe.extern.Rest<Dynamic>) -> Void):SendStream;
|
||||
/**
|
||||
Removes all listeners, or those of the specified `eventName`.
|
||||
|
||||
It is bad practice to remove listeners added elsewhere in the code,
|
||||
particularly when the `EventEmitter` instance was created by some other
|
||||
component or module (e.g. sockets or file streams).
|
||||
|
||||
Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
**/
|
||||
function removeAllListeners(?event:ts.AnyOf2<String, js.lib.Symbol>):SendStream;
|
||||
/**
|
||||
By default `EventEmitter`s will print a warning if more than `10` listeners are
|
||||
added for a particular event. This is a useful default that helps finding
|
||||
memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
|
||||
modified for this specific `EventEmitter` instance. The value can be set to`Infinity` (or `0`) to indicate an unlimited number of listeners.
|
||||
|
||||
Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
**/
|
||||
function setMaxListeners(n:Float):SendStream;
|
||||
/**
|
||||
Returns the current max listener value for the `EventEmitter` which is either
|
||||
set by `emitter.setMaxListeners(n)` or defaults to {@link defaultMaxListeners}.
|
||||
**/
|
||||
function getMaxListeners():Float;
|
||||
/**
|
||||
Returns a copy of the array of listeners for the event named `eventName`.
|
||||
|
||||
```js
|
||||
server.on('connection', (stream) => {
|
||||
console.log('someone connected!');
|
||||
});
|
||||
console.log(util.inspect(server.listeners('connection')));
|
||||
// Prints: [ [Function] ]
|
||||
```
|
||||
**/
|
||||
function listeners(eventName:ts.AnyOf2<String, js.lib.Symbol>):Array<haxe.Constraints.Function>;
|
||||
/**
|
||||
Returns a copy of the array of listeners for the event named `eventName`,
|
||||
including any wrappers (such as those created by `.once()`).
|
||||
|
||||
```js
|
||||
import { EventEmitter } from 'node:events';
|
||||
const emitter = new EventEmitter();
|
||||
emitter.once('log', () => console.log('log once'));
|
||||
|
||||
// Returns a new Array with a function `onceWrapper` which has a property
|
||||
// `listener` which contains the original listener bound above
|
||||
const listeners = emitter.rawListeners('log');
|
||||
const logFnWrapper = listeners[0];
|
||||
|
||||
// Logs "log once" to the console and does not unbind the `once` event
|
||||
logFnWrapper.listener();
|
||||
|
||||
// Logs "log once" to the console and removes the listener
|
||||
logFnWrapper();
|
||||
|
||||
emitter.on('log', () => console.log('log persistently'));
|
||||
// Will return a new Array with a single function bound by `.on()` above
|
||||
const newListeners = emitter.rawListeners('log');
|
||||
|
||||
// Logs "log persistently" twice
|
||||
newListeners[0]();
|
||||
emitter.emit('log');
|
||||
```
|
||||
**/
|
||||
function rawListeners(eventName:ts.AnyOf2<String, js.lib.Symbol>):Array<haxe.Constraints.Function>;
|
||||
/**
|
||||
Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments
|
||||
to each.
|
||||
|
||||
Returns `true` if the event had listeners, `false` otherwise.
|
||||
|
||||
```js
|
||||
import { EventEmitter } from 'node:events';
|
||||
const myEmitter = new EventEmitter();
|
||||
|
||||
// First listener
|
||||
myEmitter.on('event', function firstListener() {
|
||||
console.log('Helloooo! first listener');
|
||||
});
|
||||
// Second listener
|
||||
myEmitter.on('event', function secondListener(arg1, arg2) {
|
||||
console.log(`event with parameters ${arg1}, ${arg2} in second listener`);
|
||||
});
|
||||
// Third listener
|
||||
myEmitter.on('event', function thirdListener(...args) {
|
||||
const parameters = args.join(', ');
|
||||
console.log(`event with parameters ${parameters} in third listener`);
|
||||
});
|
||||
|
||||
console.log(myEmitter.listeners('event'));
|
||||
|
||||
myEmitter.emit('event', 1, 2, 3, 4, 5);
|
||||
|
||||
// Prints:
|
||||
// [
|
||||
// [Function: firstListener],
|
||||
// [Function: secondListener],
|
||||
// [Function: thirdListener]
|
||||
// ]
|
||||
// Helloooo! first listener
|
||||
// event with parameters 1, 2 in second listener
|
||||
// event with parameters 1, 2, 3, 4, 5 in third listener
|
||||
```
|
||||
**/
|
||||
function emit(eventName:ts.AnyOf2<String, js.lib.Symbol>, args:haxe.extern.Rest<Dynamic>):Bool;
|
||||
/**
|
||||
Returns the number of listeners listening for the event named `eventName`.
|
||||
If `listener` is provided, it will return how many times the listener is found
|
||||
in the list of the listeners of the event.
|
||||
**/
|
||||
function listenerCount(eventName:ts.AnyOf2<String, js.lib.Symbol>, ?listener:haxe.Constraints.Function):Float;
|
||||
/**
|
||||
Adds the `listener` function to the _beginning_ of the listeners array for the
|
||||
event named `eventName`. No checks are made to see if the `listener` has
|
||||
already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
|
||||
times.
|
||||
|
||||
```js
|
||||
server.prependListener('connection', (stream) => {
|
||||
console.log('someone connected!');
|
||||
});
|
||||
```
|
||||
|
||||
Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
**/
|
||||
function prependListener(eventName:ts.AnyOf2<String, js.lib.Symbol>, listener:(args:haxe.extern.Rest<Dynamic>) -> Void):SendStream;
|
||||
/**
|
||||
Adds a **one-time**`listener` function for the event named `eventName` to the _beginning_ of the listeners array. The next time `eventName` is triggered, this
|
||||
listener is removed, and then invoked.
|
||||
|
||||
```js
|
||||
server.prependOnceListener('connection', (stream) => {
|
||||
console.log('Ah, we have our first user!');
|
||||
});
|
||||
```
|
||||
|
||||
Returns a reference to the `EventEmitter`, so that calls can be chained.
|
||||
**/
|
||||
function prependOnceListener(eventName:ts.AnyOf2<String, js.lib.Symbol>, listener:(args:haxe.extern.Rest<Dynamic>) -> Void):SendStream;
|
||||
/**
|
||||
Returns an array listing the events for which the emitter has registered
|
||||
listeners. The values in the array are strings or `Symbol`s.
|
||||
|
||||
```js
|
||||
import { EventEmitter } from 'node:events';
|
||||
|
||||
const myEE = new EventEmitter();
|
||||
myEE.on('foo', () => {});
|
||||
myEE.on('bar', () => {});
|
||||
|
||||
const sym = Symbol('symbol');
|
||||
myEE.on(sym, () => {});
|
||||
|
||||
console.log(myEE.eventNames());
|
||||
// Prints: [ 'foo', 'bar', Symbol(symbol) ]
|
||||
```
|
||||
**/
|
||||
function eventNames():Array<ts.AnyOf2<String, js.lib.Symbol>>;
|
||||
};
|
||||
Reference in New Issue
Block a user