388 lines
13 KiB
Haxe
388 lines
13 KiB
Haxe
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>>;
|
|
}; |