[upd] plankton
This commit is contained in:
Christian Fraß
parent
ab747ae942
commit
bc95017f34
496
lib/plankton/plankton.d.ts
vendored
496
lib/plankton/plankton.d.ts
vendored
|
|
@ -384,400 +384,6 @@ declare class class_error extends Error {
|
|||
*/
|
||||
toString(): string;
|
||||
}
|
||||
declare module lib_call {
|
||||
/**
|
||||
* @desc hacked class for postfix function application
|
||||
* @author fenris
|
||||
*/
|
||||
class class_valuewrapper<type_value> {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
protected value: type_value;
|
||||
/**
|
||||
* @desc [constructor]
|
||||
* @author fenris
|
||||
*/
|
||||
constructor(value: type_value);
|
||||
/**
|
||||
* @desc [accessor] applies a function and returns a new valuewrapper
|
||||
* @author fenris
|
||||
*/
|
||||
pass<type_value_>(function_: (value: type_value) => type_value_): class_valuewrapper<type_value_>;
|
||||
/**
|
||||
* @desc [accessor] gives the wrapped value
|
||||
* @author fenris
|
||||
*/
|
||||
extract(): type_value;
|
||||
}
|
||||
/**
|
||||
* @desc shortcut for constructing a valuewrapper-object
|
||||
* @author fenris
|
||||
*/
|
||||
function vw<type_value>(value: type_value): class_valuewrapper<type_value>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function use<type_input, type_output>(input: type_input, function_: (input: type_input) => type_output): type_output;
|
||||
/**
|
||||
* @desc just the identity; useful for some callbacks etc.
|
||||
* @author fenris
|
||||
*/
|
||||
function id<type_value>(x: type_value): type_value;
|
||||
/**
|
||||
* @desc composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions)
|
||||
* @param {function} function_f
|
||||
* @param {function} function_g
|
||||
* @author fenris
|
||||
*/
|
||||
function compose<type_x, type_y, type_z>(function_f: (type_x: any) => type_y, function_g: (type_y: any) => type_z): (value: type_x) => type_z;
|
||||
/**
|
||||
* @desc transforms a function with sequential input into a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)
|
||||
* @param {function} f
|
||||
* @param {int} n (don't set manually)
|
||||
* @return {function} the currified version of the in put function
|
||||
* @author fenris
|
||||
*/
|
||||
function curryfy(f: Function, n?: int): Function;
|
||||
}
|
||||
declare module lib_call {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
type type_executor<type_result, type_reason> = ((resolve: (result?: type_result) => any, reject?: (reason?: type_reason) => void) => void);
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_resolve<type_result, type_reason>(result: type_result): type_executor<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_reject<type_result, type_reason>(reason: type_reason): type_executor<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_transform<type_result_from, type_error_from, type_result_to, type_error_to>(executor: type_executor<type_result_from, type_error_from>, transform_result: (result_from: type_result_from) => type_result_to, transform_reason: (error_from: type_error_from) => type_error_to): type_executor<type_result_to, type_error_to>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_transform_default<type_result_from, type_result_to>(executor: type_executor<type_result_from, Error>, transform_result: (result_from: type_result_from) => type_result_to, wrap_string?: string): type_executor<type_result_to, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_compose_sequential<type_result_first, type_result_second, type_reason>(first: type_executor<type_result_first, type_reason>, second: (result: type_result_first) => type_executor<type_result_second, type_reason>): type_executor<type_result_second, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_chain<type_state, type_error>(state: type_state, executors: Array<(state: type_state) => type_executor<type_state, type_error>>): type_executor<type_state, type_error>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_first<type_result, type_reason>(executors: Array<type_executor<type_result, type_reason>>): type_executor<type_result, Array<type_reason>>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function executor_condense<type_element>(executors: Array<type_executor<type_element, Error>>): type_executor<Array<type_element>, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated use condense
|
||||
*/
|
||||
function executor_filter<type_element>(executors: Array<type_executor<type_element, Error>>, predicate: (element: type_element) => boolean): type_executor<Array<type_element>, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated use condense
|
||||
*/
|
||||
function executor_map<type_element1, type_element2>(executors: Array<type_executor<type_element1, Error>>, transformator: (element1: type_element1) => type_element2): type_executor<Array<type_element2>, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated use condense
|
||||
*/
|
||||
function executor_reduce<type_element, type_result>(executors: Array<type_executor<type_element, Error>>, initial: type_result, accumulator: (result: type_result, element: type_element) => type_result): type_executor<type_result, Error>;
|
||||
}
|
||||
declare module lib_call {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
type type_promise<type_result, type_reason> = Promise<type_result>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_reject<type_result, type_reason>(reason: type_reason): type_promise<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_resolve<type_result, type_reason>(result: type_result): type_promise<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_make<type_result, type_reason>(executor: (resolve: (result?: type_result) => void, reject: (reason?: type_reason) => void) => void): type_promise<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_then_close<type_result, type_reason>(promise: type_promise<type_result, type_reason>, resolver: (result: type_result) => void, rejector: (reason: type_reason) => void): void;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_then_append<type_result, type_reason, type_result_>(promise: type_promise<type_result, type_reason>, resolver: (result: type_result) => type_promise<type_result_, type_reason>, rejector?: (reason: type_reason) => type_promise<type_result_, type_reason>): type_promise<type_result_, type_result>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_all<type_result, type_reason>(promises: Array<type_promise<type_result, type_reason>>): type_promise<Array<type_result>, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_chain<type_result, type_reason>(promises: Array<(input: type_result) => type_promise<type_result, type_reason>>, start?: type_result): type_promise<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_condense<type_element, type_reason>(promises: Array<() => type_promise<type_element, type_reason>>): type_promise<Array<type_element>, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_group<type_reason>(promises: {
|
||||
[name: string]: () => type_promise<any, type_reason>;
|
||||
}, serial?: boolean): type_promise<{
|
||||
[name: string]: any;
|
||||
}, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_wrap<type_result_inner, type_result_outer, type_reason>(promise: type_promise<type_result_inner, type_reason>, transformator_result: (reason: type_result_inner) => type_result_outer, transformator_reason?: (reason: type_reason) => type_reason): type_promise<type_result_outer, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_show<type_result, type_reason>(label: string): (result: type_result) => type_promise<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_log<type_result, type_reason>(result: type_result): (result: type_result) => type_promise<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_attach<type_reason>(state: {
|
||||
[name: string]: any;
|
||||
}, promise: type_promise<any, type_reason>, name: string): type_promise<{
|
||||
[name: string]: any;
|
||||
}, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_delay<type_result, type_reason>(promise: type_promise<type_result, type_reason>, delay: int): type_promise<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function promise_to_executor<type_result, type_reason>(promise: type_promise<type_result, type_reason>): type_executor<type_result, type_reason>;
|
||||
}
|
||||
declare module lib_call {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
type type_initializer_state = int;
|
||||
const initializer_state_initial: type_initializer_state;
|
||||
const initializer_state_waiting: type_initializer_state;
|
||||
const initializer_state_successful: type_initializer_state;
|
||||
const initializer_state_failed: type_initializer_state;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
type type_initializer<type_result, type_reason> = {
|
||||
fetcher: () => type_promise<type_result, type_reason>;
|
||||
state?: type_initializer_state;
|
||||
queue: Array<{
|
||||
resolve: (result?: type_result) => void;
|
||||
reject: (reason?: type_reason) => void;
|
||||
}>;
|
||||
result?: type_result;
|
||||
reason?: type_reason;
|
||||
};
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function initializer_make<type_result, type_reason>(fetcher: () => type_promise<type_result, type_reason>): type_initializer<type_result, type_reason>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function initializer_reset<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): void;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function initializer_state<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): type_initializer_state;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function initializer_get<type_result, type_reason>(subject: type_initializer<type_result, type_reason>): type_promise<type_result, type_reason>;
|
||||
}
|
||||
declare module lib_call {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
type type_deferral<type_input, type_output> = {
|
||||
representation: (input: type_input) => Promise<type_output>;
|
||||
};
|
||||
/**
|
||||
* @author fenris
|
||||
* @desc activates the deferral and handles its output according to a given procedure
|
||||
* @param {(value : type_value)=>void} procedure a function which receives the output of the deferral as argument
|
||||
*/
|
||||
function deferral_use<type_input, type_output>(deferral: type_deferral<type_input, type_output>, input: type_input, procedure: (output: type_output) => void): void;
|
||||
/**
|
||||
* @author fenris
|
||||
* @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject")
|
||||
*/
|
||||
function deferral_make<type_input, type_output>(handler: (input: type_input, convey: (output: type_output) => void) => void): type_deferral<type_input, type_output>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject")
|
||||
*/
|
||||
function deferral_wrap<type_input, type_output>(function_: (input: type_input) => type_output): type_deferral<type_input, type_output>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function deferral_id<type_value>(): type_deferral<type_value, type_value>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function deferral_const<type_value>(value: type_value): type_deferral<type_value, type_value>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function deferral_delay<type_output>(output: type_output, delay: int): type_deferral<any, type_output>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @desc connects two deferrals to form a new one; the output of the first is taken as input for the second
|
||||
* (similar to "Promise.then" when passing a function which returns a new promise)
|
||||
* @param {type_deferral<type_value1>} first a simple deferral
|
||||
* @param {(value1 : type_value1)=>type_deferral<type_value2>} second a function depending from a value returning a deferral
|
||||
*/
|
||||
function deferral_compose_serial<type_input, type_between, type_output>(first: type_deferral<type_input, type_between>, second: type_deferral<type_between, type_output>): type_deferral<type_input, type_output>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function deferral_compose_parallel<type_input, type_output_left, type_output_right>({ "left": deferral_left, "right": deferral_right, }: {
|
||||
left: type_deferral<type_input, type_output_left>;
|
||||
right: type_deferral<type_input, type_output_right>;
|
||||
}): type_deferral<type_input, {
|
||||
left: type_output_left;
|
||||
right: type_output_right;
|
||||
}>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @desc repeatedly applied serial composition
|
||||
*/
|
||||
function deferral_chain<type_value>(members: Array<type_deferral<type_value, type_value>>): type_deferral<type_value, type_value>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
}
|
||||
declare module lib_call {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
class class_deferral<type_input, type_output> {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
private subject;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
private constructor();
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
private static _cram;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
private static _tear;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
static make<type_input, type_output>(handler: (input: type_input, convey: (value: type_output) => void) => void): class_deferral<type_input, type_output>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
use(input: type_input, procedure: (value: type_output) => void): void;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
compose_serial<type_output_>(second: class_deferral<type_output, type_output_>): class_deferral<type_input, type_output_>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
static chain<type_value>(members: Array<class_deferral<type_value, type_value>>): class_deferral<type_value, type_value>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
static wrap<type_input, type_output>(function_: (input: type_input) => type_output): class_deferral<type_input, type_output>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
static const_<type_value>(value: type_value): class_deferral<type_value, type_value>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
static delay<type_output>(output: type_output, delay: int): class_deferral<any, type_output>;
|
||||
}
|
||||
}
|
||||
declare module lib_call {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function timeout(function_: () => void, delay: int): int;
|
||||
/**
|
||||
* @desc a definition for a value being "defined"
|
||||
* @author neuc
|
||||
*/
|
||||
function is_def<type_value>(obj: type_value, null_is_valid?: boolean): boolean;
|
||||
/**
|
||||
* @desc returns the value if set and, when a type is specified, if the type is correct, if not return default_value
|
||||
* @author neuc
|
||||
*/
|
||||
function def_val(value: any, default_value: any, type?: string, null_is_valid?: boolean): any;
|
||||
/**
|
||||
* @desc just the empty function; useful for some callbacks etc.
|
||||
* @author fenris
|
||||
*/
|
||||
function nothing(): void;
|
||||
/**
|
||||
* @desc outputs
|
||||
* @author fenris
|
||||
*/
|
||||
function output(...args: Array<any>): void;
|
||||
/**
|
||||
* @desc converts the "arguments"-map into an array
|
||||
* @param {Object} args
|
||||
* @author fenris
|
||||
*/
|
||||
function args2list(args: any): Array<any>;
|
||||
/**
|
||||
* @desc provides the call for an attribute of a class as a regular function
|
||||
* @param {string} name the name of the attribute
|
||||
* @return {*}
|
||||
* @author fenris
|
||||
*/
|
||||
function attribute<type_object, type_attribute>(name: string): (object: type_object) => type_attribute;
|
||||
/**
|
||||
* @desc provides a method of a class as a regular function
|
||||
* @param {string} name the name of the method
|
||||
* @return {function}
|
||||
* @author fenris
|
||||
*/
|
||||
function method<type_object, type_output>(name: string): (object: type_object) => type_output;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
type type_unival = {
|
||||
kind: string;
|
||||
data?: any;
|
||||
};
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function distinguish(unival: type_unival, handlers: {
|
||||
[kind: string]: (data?: any) => any;
|
||||
}, fallback?: (unival?: type_unival) => any): any;
|
||||
}
|
||||
declare namespace lib_plankton.log {
|
||||
/**
|
||||
*/
|
||||
|
|
@ -1143,115 +749,19 @@ declare module lib_args {
|
|||
}): string;
|
||||
}
|
||||
}
|
||||
declare module lib_client {
|
||||
declare namespace lib_plankton.file {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
type type_subject = {
|
||||
host: string;
|
||||
port: int;
|
||||
verbosity: int;
|
||||
};
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function make(host: string, port: int, verbosity?: int): type_subject;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function query(subject: type_subject, input: string): Promise<string>;
|
||||
}
|
||||
declare module lib_client {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
class class_client {
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
protected subject: type_subject;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
constructor(host: string, port: int, verbosity: int);
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
query(input: string): Promise<string>;
|
||||
}
|
||||
}
|
||||
declare module lib_file {
|
||||
/**
|
||||
* @author fenris,maspr
|
||||
* @todo clear up if http(s)-handling belongs here or not ...
|
||||
*/
|
||||
function read_promise(path: string): lib_call.type_promise<string, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function write_promise(path: string, content: string): lib_call.type_promise<void, Error>;
|
||||
function read(path: string): Promise<string>;
|
||||
/**
|
||||
* @author fenris
|
||||
*/
|
||||
function read_stdin(): Promise<string>;
|
||||
}
|
||||
declare module lib_file {
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated lib_file shouldn't care for code stuff; use a combination of lib_file and lib_code instead
|
||||
*/
|
||||
function read_json_promise(path: string): lib_call.type_promise<any, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated lib_file shouldn't care for code stuff; use a combination of lib_file and lib_code instead
|
||||
*/
|
||||
function write_json_promise(path: string, data: any): lib_call.type_promise<void, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated use promises instead of executors
|
||||
*/
|
||||
function read_executor(path: string): lib_call.type_executor<string, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated use promises instead of executors
|
||||
*/
|
||||
function write_executor(path: string, content: string): lib_call.type_executor<void, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated lib_file shouldn't care for code stuff; use a combination of lib_file and lib_code instead
|
||||
* @deprecated use promises instead of executors
|
||||
*/
|
||||
function read_json_executor(path: string): lib_call.type_executor<any, Error>;
|
||||
/**
|
||||
* @author fenris
|
||||
* @deprecated lib_file shouldn't care for code stuff; use a combination of lib_file and lib_code instead
|
||||
* @deprecated use promises instead of executors
|
||||
*/
|
||||
function write_json_executor(path: string, data: any): lib_call.type_executor<void, Error>;
|
||||
/**
|
||||
* @desc reads a file
|
||||
* @author fenris
|
||||
* @todo replace with promise version
|
||||
*/
|
||||
function read(path: string): lib_call.type_executor<string, Error>;
|
||||
/**
|
||||
* @desc writes a file
|
||||
* @author fenris
|
||||
* @todo replace with promise version
|
||||
*/
|
||||
function write(path: string, content: string): lib_call.type_executor<void, Error>;
|
||||
/**
|
||||
* @desc reads a json file
|
||||
* @author fenris
|
||||
* @deprecated lib_file shouldn't care for code stuff; use a combination of lib_file and lib_code instead
|
||||
*/
|
||||
function read_json(path: string): lib_call.type_executor<any, Error>;
|
||||
/**
|
||||
* @desc writes a json file
|
||||
* @author fenris
|
||||
* @deprecated lib_file shouldn't care for code stuff; use a combination of lib_file and lib_code instead
|
||||
*/
|
||||
function write_json(path: string, data: any): lib_call.type_executor<void, Error>;
|
||||
function write(path: string, content: string): Promise<void>;
|
||||
}
|
||||
declare module lib_observer {
|
||||
/**
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
Loading…
Reference in a new issue