3752 lines
105 KiB
TypeScript
3752 lines
105 KiB
TypeScript
/**
|
|
* @author fenris
|
|
*/
|
|
type int = number;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type float = number;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_date = {
|
|
year: int;
|
|
month: int;
|
|
day: int;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_time = {
|
|
hour: int;
|
|
minute: int;
|
|
second: int;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_datetimeobject = {
|
|
date: type_date;
|
|
time: type_time;
|
|
};
|
|
declare class Buffer {
|
|
constructor(x: string, modifier?: string);
|
|
toString(modifier?: string): string;
|
|
}
|
|
declare namespace lib_plankton.base {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function environment(): string;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_pseudopointer<type_value> = {
|
|
value: type_value;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function pseudopointer_null<type_value>(): type_pseudopointer<type_value>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function pseudopointer_make<type_value>(value: type_value): type_pseudopointer<type_value>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function pseudopointer_isset<type_value>(pseudopointer: type_pseudopointer<type_value>): boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function pseudopointer_read<type_value>(pseudopointer: type_pseudopointer<type_value>): type_value;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function pseudopointer_write<type_value>(pseudopointer: type_pseudopointer<type_value>, value: type_value): void;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare var instance_verbosity: int;
|
|
/**
|
|
* @desc the ability to check for equality with another element of the same domain
|
|
* @author fenris
|
|
*/
|
|
interface interface_collatable<type_value> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
_collate(value: type_value): boolean;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function instance_collate<type_value>(value1: (type_value & {
|
|
_collate?: ((value: type_value) => boolean);
|
|
}), value2: type_value): boolean;
|
|
/**
|
|
* @desc the ability to compare with another element of the same domain for determining if the first is "smaller than or equal to" the latter
|
|
* @author fenris
|
|
*/
|
|
interface interface_comparable<type_value> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
_compare(value: type_value): boolean;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function instance_compare<type_value>(value1: (type_value & {
|
|
_compare: ((value: type_value) => boolean);
|
|
}), value2: type_value): boolean;
|
|
/**
|
|
* @desc the ability to create an exact copy
|
|
* @author fenris
|
|
*/
|
|
interface interface_cloneable<type_value> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
_clone(): type_value;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare function instance_clone<type_value>(value: (type_value & {
|
|
_clone?: (() => type_value);
|
|
})): type_value;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
interface interface_hashable {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
_hash(): string;
|
|
}
|
|
/**
|
|
* @desc the ability to generate a string out of the element, which identifies it to a high degree
|
|
* @author fenris
|
|
*/
|
|
declare function instance_hash<type_value>(value: (type_value & {
|
|
_hash?: (() => string);
|
|
})): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
interface interface_showable {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
_show(): string;
|
|
}
|
|
/**
|
|
* @desc the ability to map the element to a textual representation (most likely not injective)
|
|
* @author fenris
|
|
*/
|
|
declare function instance_show<type_value>(value: (type_value & {
|
|
_show?: (() => string);
|
|
})): string;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
interface interface_decorator<type_core> {
|
|
/**
|
|
* @author frac
|
|
*/
|
|
core: type_core;
|
|
}
|
|
/**
|
|
* @author frac
|
|
*/
|
|
declare class class_observer {
|
|
/**
|
|
* @author frac
|
|
*/
|
|
protected counter: int;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
protected actions: {
|
|
[id: string]: (information: Object) => void;
|
|
};
|
|
/**
|
|
* @author frac
|
|
*/
|
|
protected buffer: Array<Object>;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
constructor();
|
|
/**
|
|
* @author frac
|
|
*/
|
|
empty(): boolean;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
flush(): void;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
set(id: string, action: (information: Object) => void): void;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
del(id: string): void;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
add(action: (information: Object) => void): void;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
notify(information?: Object, delayed?: boolean): void;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
rollout(): void;
|
|
}
|
|
/**
|
|
* @author frac
|
|
*/
|
|
/**
|
|
* @author frac
|
|
*/
|
|
/**
|
|
* @author frac
|
|
*/
|
|
declare class class_error extends Error {
|
|
/**
|
|
* @author frac
|
|
*/
|
|
protected suberrors: Array<Error>;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
protected mess: string;
|
|
/**
|
|
* @author frac
|
|
*/
|
|
constructor(message: string, suberrors?: Array<Error>);
|
|
/**
|
|
* @override
|
|
* @author frac
|
|
*/
|
|
toString(): string;
|
|
}
|
|
declare namespace lib_plankton.base {
|
|
/**
|
|
* returns the current UNIX timestamp
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function get_current_timestamp(rounded?: boolean): float;
|
|
/**
|
|
*/
|
|
function object_merge(core: Record<string, any>, mantle: Record<string, any>): Record<string, any>;
|
|
}
|
|
declare module lib_plankton.pod {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_pod<type_value> = {
|
|
kind: ("empty" | "filled");
|
|
value?: type_value;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function make_empty<type_value>(): type_pod<type_value>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function make_filled<type_value>(value: type_value): type_pod<type_value>;
|
|
/**
|
|
* whether the pod is filled
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function is_filled<type_value>(pod: type_pod<type_value>): boolean;
|
|
/**
|
|
* return the value, stored in the pod-wrapper
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function cull<type_value>(pod: type_pod<type_value>): type_value;
|
|
/**
|
|
* to pass on a empty-pod or to use a filled-pod
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function propagate<type_value, type_value_>(pod: type_pod<type_value>, function_: ((value: type_value) => type_value_)): type_pod<type_value_>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function distinguish<type_value, type_result>(pod: type_pod<type_value>, function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result;
|
|
/**
|
|
*/
|
|
function show<type_value>(pod: type_pod<type_value>, options?: {
|
|
show_value?: ((value: type_value) => string);
|
|
}): string;
|
|
}
|
|
declare module lib_plankton.pod {
|
|
/**
|
|
*/
|
|
class class_pod<type_value> {
|
|
private subject;
|
|
constructor(subject: type_pod<type_value>);
|
|
tear(): type_pod<type_value>;
|
|
static empty<type_value>(): class_pod<type_value>;
|
|
static filled<type_value>(value: type_value): class_pod<type_value>;
|
|
is_empty(): boolean;
|
|
is_filled(): boolean;
|
|
cull(): type_value;
|
|
show(show_value?: any): string;
|
|
toString(): string;
|
|
propagate<type_value_>(function_: ((value: type_value) => type_value_)): class_pod<type_value_>;
|
|
distinguish<type_result>(function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
interface interface_code<type_from, type_to> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
encode(x: type_from): type_to;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
decode(x: type_to): type_from;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_code<type_from, type_to> = {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
encode: (x: type_from) => type_to;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
decode: (x: type_to) => type_from;
|
|
};
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function inverse_encode<type_from, type_to>(decode: (to: type_to) => type_from, to: type_to): type_from;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function inverse_decode<type_from, type_to>(encode: (from: type_from) => type_to, from: type_from): type_to;
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_code_inverse<type_from, type_to> implements interface_code<type_to, type_from> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected subject: interface_code<type_from, type_to>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(subject: interface_code<type_from, type_to>);
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(to: type_to): type_from;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(from: type_from): type_to;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function pair_encode<type_from, type_between, type_to>(encode_first: (from: type_from) => type_between, encode_second: (between: type_between) => type_to, from: type_from): type_to;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function pair_decode<type_from, type_between, type_to>(decode_first: (between: type_between) => type_from, decode_second: (to: type_to) => type_between, to: type_to): type_from;
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_code_pair<type_from, type_between, type_to> implements interface_code<type_from, type_to> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected first: interface_code<type_from, type_between>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected second: interface_code<type_between, type_to>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(first: interface_code<type_from, type_between>, second: interface_code<type_between, type_to>);
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(from: type_from): type_to;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(to: type_to): type_from;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function chain_encode(encode_links: Array<(from: any) => any>, from: any): any;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function chain_decode(decode_links: Array<(to: any) => any>, to: any): any;
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_code_chain implements interface_code<any, any> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected links: Array<interface_code<any, any>>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(links: Array<interface_code<any, any>>);
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(from: any): any;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(to: any): any;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author Christian Fraß <frass@greenscale.de>
|
|
*/
|
|
type type_flatten_from = Array<{
|
|
[name: string]: any;
|
|
}>;
|
|
/**
|
|
* @author Christian Fraß <frass@greenscale.de>
|
|
*/
|
|
type type_flatten_to = {
|
|
keys: Array<string>;
|
|
data: Array<Array<any>>;
|
|
};
|
|
/**
|
|
* @author Christian Fraß <frass@greenscale.de>
|
|
*/
|
|
function flatten_encode(from: type_flatten_from, keys?: Array<string>): type_flatten_to;
|
|
/**
|
|
* @author Christian Fraß <frass@greenscale.de>
|
|
*/
|
|
function flatten_decode(to: type_flatten_to): type_flatten_from;
|
|
}
|
|
declare namespace lib_plankton.code {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_code_flatten implements interface_code<type_flatten_from, type_flatten_to> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor();
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(x: type_flatten_from): type_flatten_to;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(x: type_flatten_to): type_flatten_from;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.json {
|
|
/**
|
|
*/
|
|
type type_source = any;
|
|
/**
|
|
*/
|
|
type type_target = string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
export function encode(source: type_source, options?: {
|
|
formatted?: boolean;
|
|
}): type_target;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
export function decode(target: type_target): type_source;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
export function implementation_code(): lib_plankton.code.type_code<type_source, type_target>;
|
|
export {};
|
|
}
|
|
declare namespace lib_plankton.json {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_json implements lib_plankton.code.interface_code<any, string> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor();
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(x: any): string;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(x: string): any;
|
|
}
|
|
}
|
|
/**
|
|
* might be completely obsolete
|
|
*/
|
|
declare namespace lib_plankton.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: Record<string, (() => type_promise<any, type_reason>)>, options?: {
|
|
serial?: boolean;
|
|
}): type_promise<Record<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
|
|
*/
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function promise_attach<type_reason>(state: Record<string, any>, promise: type_promise<any, type_reason>, name: string): type_promise<Record<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>;
|
|
}
|
|
declare namespace lib_plankton.call {
|
|
/**
|
|
*/
|
|
class CancellablePromise<type_result> extends Promise<type_result> {
|
|
/**
|
|
*/
|
|
private cancelled;
|
|
/**
|
|
*/
|
|
private interval;
|
|
/**
|
|
*/
|
|
private subject;
|
|
/**
|
|
*/
|
|
constructor(executor: ((resolve: any, reject: any) => void));
|
|
/**
|
|
*/
|
|
private clear;
|
|
/**
|
|
*/
|
|
then<type_next_resolved, type_next_rejected>(onfulfilled?: ((value: type_result) => (type_next_resolved | PromiseLike<type_next_resolved>)), onrejected?: ((reason: any) => (type_next_rejected | PromiseLike<type_next_rejected>))): Promise<type_next_resolved | type_next_rejected>;
|
|
/**
|
|
*/
|
|
catch(x: any): Promise<type_result>;
|
|
/**
|
|
*/
|
|
cancel(): void;
|
|
}
|
|
}
|
|
/**
|
|
* initializer might be obsolete, since promises are reusable after having been resolved or rejected
|
|
*/
|
|
declare namespace lib_plankton.call {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
enum enum_initializer_state {
|
|
initial = 0,
|
|
waiting = 1,
|
|
successful = 2,
|
|
failed = 3
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_initializer<type_result, type_reason> = {
|
|
fetcher: (() => type_promise<type_result, type_reason>);
|
|
state?: enum_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>): enum_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 namespace lib_plankton.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 namespace lib_plankton.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 namespace lib_plankton.call {
|
|
/**
|
|
* converts the "arguments"-map into an array
|
|
*
|
|
* @param {Object} args
|
|
* @author fenris
|
|
*/
|
|
function args2list(args: any): Array<any>;
|
|
/**
|
|
* just the empty function; useful for some callbacks etc.
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function nothing(): void;
|
|
/**
|
|
* just the identity; useful for some callbacks etc.; defined as function instead of const for using type parameters
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function id<type_value>(x: type_value): type_value;
|
|
/**
|
|
* just the identity; useful for some callbacks etc.
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function const_<type_value>(x: type_value): ((y: any) => type_value);
|
|
/**
|
|
* 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);
|
|
/**
|
|
* transforms a function with sequential input to a function with leveled input; example: add(2,3) = curryfy(add)(2)(3)
|
|
*
|
|
* @param {function} f
|
|
* @return {function} the currified version of the in put function
|
|
* @author fenris
|
|
*/
|
|
function curryfy(f: Function): Function;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function convey(value: any, functions: Array<Function>): any;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function timeout(procedure: (() => void), delay_in_seconds: float): int;
|
|
/**
|
|
* Promise version of "setTimeout"
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function defer<type_result>(seconds: float, action: (() => type_result)): Promise<type_result>;
|
|
/**
|
|
* a definition for a value being "defined"
|
|
*
|
|
* @author neuc
|
|
*/
|
|
function is_def<type_value>(obj: type_value, options?: {
|
|
null_is_valid?: boolean;
|
|
}): boolean;
|
|
/**
|
|
* 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, options?: {
|
|
type?: (null | string);
|
|
null_is_valid?: boolean;
|
|
}): any;
|
|
/**
|
|
* provides the call for an attribute of a class as a regular function; useful for processing lists of objects
|
|
*
|
|
* @param {string} name the name of the attribute
|
|
* @return {function}
|
|
* @author fenris
|
|
*/
|
|
function attribute<type_object, type_attribute>(name: string): ((object: type_object) => type_attribute);
|
|
/**
|
|
* provides a method of a class as a regular function; useful for processing lists of objects
|
|
*
|
|
* @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_coproduct = {
|
|
kind: string;
|
|
data?: any;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function distinguish<type_output>(coproduct: type_coproduct, handlers: Record<string, ((data?: any) => type_output)>, options?: {
|
|
fallback?: (null | ((coproduct?: type_coproduct) => type_output));
|
|
}): type_output;
|
|
/**
|
|
* for rate_limit_check
|
|
*
|
|
* @author fenris
|
|
*/
|
|
type type_mana_snapshot = {
|
|
timestamp: float;
|
|
value: float;
|
|
};
|
|
/**
|
|
* rate limiting algorithm, based on the idea of mana (magic power) in video games:
|
|
* - an actor has a fixed mana capacity, i.e. the maximum amount of available power
|
|
* - an actor has a fixed rate of mana regeneration, i.e. how fast the power is filled up (linear growth)
|
|
* - an action has a defined mana heft, i.e. how much power is required and deducted in order to execute it
|
|
* - mana states are represented by snapshots, i.e. the amount of power at a certain point in time
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function rate_limit_check(setup: {
|
|
capacity: float;
|
|
regeneration_rate: float;
|
|
get_snapshot: (() => Promise<(null | type_mana_snapshot)>);
|
|
set_snapshot: ((snapshot: type_mana_snapshot) => Promise<void>);
|
|
update_snapshot: ((timestamp: float, value_increment: float) => Promise<void>);
|
|
}, heft: float): Promise<{
|
|
granted: boolean;
|
|
seconds: (null | float);
|
|
}>;
|
|
}
|
|
declare namespace lib_plankton.file {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function read(path: string): Promise<string>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function write(path: string, content: string): Promise<void>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function blob_read_text(blob: Blob): lib_plankton.call.type_promise<string, Error>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function blob_read_arraybuffer(blob: Blob): lib_plankton.call.type_promise<ArrayBuffer, Error>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function blob_read_dataurl(blob: Blob): lib_plankton.call.type_promise<string, Error>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function blob_write_text(text: string): lib_plankton.call.type_promise<Blob, Error>;
|
|
}
|
|
declare namespace lib_plankton.email {
|
|
/**
|
|
*/
|
|
function send(smtp_credentials: {
|
|
host: string;
|
|
port: int;
|
|
username: string;
|
|
password: string;
|
|
}, sender: string, receivers: Array<string>, subject: string, content: string): Promise<void>;
|
|
}
|
|
declare namespace lib_plankton.log {
|
|
/**
|
|
*/
|
|
enum enum_level {
|
|
debug = 0,
|
|
info = 1,
|
|
notice = 2,
|
|
warning = 3,
|
|
error = 4
|
|
}
|
|
/**
|
|
*/
|
|
function level_order(level1: enum_level, level2: enum_level): boolean;
|
|
/**
|
|
*/
|
|
function level_show(level: enum_level): string;
|
|
/**
|
|
*/
|
|
type type_entry = {
|
|
level: enum_level;
|
|
incident: string;
|
|
details: Record<string, any>;
|
|
};
|
|
}
|
|
/**
|
|
* @deprecated
|
|
* @todo remove
|
|
*/
|
|
declare namespace lib_plankton.log {
|
|
function level_push(level: int): void;
|
|
function level_pop(): void;
|
|
function indent_push(indent: int): void;
|
|
function indent_pop(): void;
|
|
function indent_inc(): void;
|
|
function indent_dec(): void;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function write({ "message": message, "type": type, "prefix": prefix, "level": level, "indent": indent, }: {
|
|
message?: string;
|
|
type?: string;
|
|
prefix?: string;
|
|
level?: int;
|
|
indent?: int;
|
|
}): void;
|
|
}
|
|
declare namespace lib_plankton.log {
|
|
/**
|
|
*/
|
|
abstract class class_channel {
|
|
/**
|
|
*/
|
|
abstract add(entry: type_entry): void;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.log {
|
|
/**
|
|
* output for writing log entries to web console
|
|
*/
|
|
class class_channel_console extends class_channel {
|
|
/**
|
|
*/
|
|
add(entry: type_entry): void;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.log {
|
|
/**
|
|
* decorator for filtering out log entries below a certain level threshold
|
|
*/
|
|
class class_channel_minlevel extends class_channel {
|
|
/**
|
|
*/
|
|
private core;
|
|
/**
|
|
*/
|
|
private threshold;
|
|
/**
|
|
*/
|
|
constructor(core: class_channel, threshold: enum_level);
|
|
/**
|
|
*/
|
|
add(entry: type_entry): void;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.log {
|
|
/**
|
|
*/
|
|
function channel_make(description: {
|
|
kind: string;
|
|
data?: {
|
|
[key: string]: any;
|
|
};
|
|
}): class_channel;
|
|
/**
|
|
*/
|
|
type type_configuration = Array<class_channel>;
|
|
/**
|
|
*/
|
|
function conf_default(): type_configuration;
|
|
}
|
|
declare namespace lib_plankton.log {
|
|
/**
|
|
* pushes a new configuration on the stack and activates it
|
|
*/
|
|
function conf_push(channels: type_configuration): void;
|
|
/**
|
|
* pops the current active configuration from the stack
|
|
*/
|
|
function conf_pop(): void;
|
|
/**
|
|
* consumes a log entry, i.e. sends it to the currently active outputs
|
|
*/
|
|
function add(entry: type_entry): void;
|
|
/**
|
|
*/
|
|
function debug(incident: string, details?: Record<string, any>): void;
|
|
/**
|
|
*/
|
|
function info(incident: string, details?: Record<string, any>): void;
|
|
/**
|
|
*/
|
|
function notice(incident: string, details?: Record<string, any>): void;
|
|
/**
|
|
*/
|
|
function warning(incident: string, details?: Record<string, any>): void;
|
|
/**
|
|
*/
|
|
function error(incident: string, details?: Record<string, any>): void;
|
|
}
|
|
declare namespace lib_plankton.log {
|
|
}
|
|
declare namespace lib_plankton.object {
|
|
/**
|
|
* @author fenris
|
|
* @deprecated use the "??" operator instead
|
|
*/
|
|
function fetch<type_value>(object: Object, fieldname: string, options?: {
|
|
fallback?: type_value;
|
|
escalate?: boolean;
|
|
}): type_value;
|
|
/**
|
|
*/
|
|
function map<type_from, type_to>(object_from: Record<string, type_from>, transformator: ((value_from: type_from, key?: string) => type_to)): Record<string, type_to>;
|
|
/**
|
|
* gibt ein Objekt mit bestimmten Einträgen des Eingabe-Objekts zurück
|
|
*/
|
|
function filter<type_value>(object_from: Record<string, type_value>, predicate: ((value_from: type_value, key?: string) => boolean)): Record<string, type_value>;
|
|
/**
|
|
* wandelt ein Array mit Einträgen der Form {key,value} in ein entsprechendes Objekt um
|
|
*
|
|
* @deprecated use Object.fromEntries instead!
|
|
*/
|
|
function from_array<type_value>(array: Array<{
|
|
key: string;
|
|
value: type_value;
|
|
}>): Record<string, type_value>;
|
|
/**
|
|
* wandelt ein Objekt in ein entsprechendes Array mit Einträgen der Form {key,value} um
|
|
*
|
|
* @deprecated use Object.entries insetad!
|
|
*/
|
|
function to_array<type_value>(object: Record<string, type_value>): Array<{
|
|
key: string;
|
|
value: type_value;
|
|
}>;
|
|
/**
|
|
* gibt eine Liste von Schlüsseln eines Objekts zurück
|
|
*
|
|
* @deprecated use Object.keys instead!
|
|
*/
|
|
function keys(object: Record<string, any>): Array<string>;
|
|
/**
|
|
* gibt eine Liste von Werten eines Objekts zurück
|
|
*
|
|
* @deprecated use Object.values instead!
|
|
*/
|
|
function values<type_value>(object: Record<string, type_value>): Array<type_value>;
|
|
/**
|
|
* liest ein Baum-artiges Objekt an einer bestimmten Stelle aus
|
|
*/
|
|
function path_read<type_value>(object: Object, path: string, options?: {
|
|
fallback?: type_value;
|
|
escalate?: boolean;
|
|
}): type_value;
|
|
/**
|
|
* schreibt einen Wert an eine bestimmte Stelle in einem Baum-artigen Objekt
|
|
*/
|
|
function path_write<type_value>(object: Object, path: string, value: type_value, construct?: boolean): void;
|
|
/**
|
|
* prüft ob ein Objekt einem bestimmten Muster entspricht
|
|
*
|
|
* @deprecated not very useful
|
|
*/
|
|
function matches<type_value_object, type_value_pattern>(object: Record<string, type_value_object>, pattern: Record<string, type_value_pattern>, options?: {
|
|
collate?: ((value_pattern: type_value_pattern, value_object: type_value_object) => boolean);
|
|
}): boolean;
|
|
/**
|
|
* erzeugt eine Projektion eines Baum-artigen Objekts in ein Listen-artiges Objekt
|
|
*/
|
|
function flatten(value: any, options?: {
|
|
separator?: string;
|
|
key_for_array_element?: ((index: int) => string);
|
|
}): Record<string, any>;
|
|
/**
|
|
* @deprecated use Object.assign instead!
|
|
*/
|
|
function clash(x: Record<string, any>, y: Record<string, any>, options?: {
|
|
overwrite?: boolean;
|
|
hooks?: {
|
|
existing?: ((key?: string, value_old?: any, value_new?: any) => void);
|
|
};
|
|
}): Record<string, any>;
|
|
/**
|
|
* @deprecated use Object.assign instead!
|
|
*/
|
|
function patch(core: (null | Record<string, any>), mantle: (null | Record<string, any>), options?: {
|
|
deep?: boolean;
|
|
path?: (null | string);
|
|
}): void;
|
|
/**
|
|
* @deprecated use Object.assign instead!
|
|
*/
|
|
function patched(core: Record<string, any>, mantle: Record<string, any>, options?: {
|
|
deep?: boolean;
|
|
}): Record<string, any>;
|
|
/**
|
|
* @deprecated use Object.assign instead!
|
|
*/
|
|
function attached(object: Record<string, any>, key: string, value: any): Record<string, any>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function copy(object: Record<string, any>): Record<string, any>;
|
|
}
|
|
declare namespace lib_plankton.pair {
|
|
/**
|
|
*/
|
|
type type_pair<type_first, type_second> = {
|
|
first: type_first;
|
|
second: type_second;
|
|
};
|
|
}
|
|
declare namespace lib_plankton.pair {
|
|
/**
|
|
*/
|
|
function swap<type_first, type_second>(pair: type_pair<type_first, type_second>): type_pair<type_second, type_first>;
|
|
/**
|
|
*/
|
|
function show<type_first, type_second>(pair: type_pair<type_first, type_second>, options?: {
|
|
show_first?: ((first: type_first) => string);
|
|
show_second?: ((second: type_second) => string);
|
|
}): string;
|
|
}
|
|
declare namespace lib_plankton.list {
|
|
/**
|
|
*/
|
|
type type_separation<type_element> = {
|
|
yes: Array<type_element>;
|
|
no: Array<type_element>;
|
|
};
|
|
/**
|
|
*/
|
|
type type_result_max<type_element, type_value> = (null | {
|
|
index: int;
|
|
element: type_element;
|
|
value: type_value;
|
|
});
|
|
}
|
|
declare namespace lib_plankton.list {
|
|
/**
|
|
* returns a certain list of integer numbers
|
|
*/
|
|
function range(from: int, to: int, options?: {
|
|
step?: int;
|
|
}): Array<int>;
|
|
/**
|
|
* returns a certain list of consecutiv integer numbers, beginning with 0
|
|
*/
|
|
function sequence(length: int): Array<int>;
|
|
/**
|
|
*/
|
|
function from_iterator<type_element>(iterator: Iterator<type_element>): Array<type_element>;
|
|
/**
|
|
*/
|
|
function is_empty<type_element>(list: Array<type_element>): boolean;
|
|
/**
|
|
* combines two lists into one
|
|
*
|
|
* @param {boolean} [options.cut] whether the result list will be as long as the shortest input list or an exception is thrown if they have different lengths; default: true
|
|
*/
|
|
function zip<type_element_first, type_element_second>(list_first: Array<type_element_first>, list_second: Array<type_element_second>, options?: {
|
|
cut?: boolean;
|
|
}): Array<lib_plankton.pair.type_pair<type_element_first, type_element_second>>;
|
|
/**
|
|
* checks whether two lists are equal
|
|
*
|
|
* @todo define common function "equals" and default predicate to
|
|
*/
|
|
function equals<type_element>(list1: Array<type_element>, list2: Array<type_element>, options?: {
|
|
collate_element?: ((element1: type_element, element2: type_element) => boolean);
|
|
}): boolean;
|
|
/**
|
|
* creates a list with the elements from the input list, which fulfil a certain predicate (~ filter)
|
|
*/
|
|
function keep<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): Array<type_element>;
|
|
/**
|
|
* creates a list with the elements from the input list, which do not fulfil a certain predicate (~ dual filter)
|
|
*/
|
|
function drop<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): Array<type_element>;
|
|
/**
|
|
*/
|
|
function filter_inplace<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): void;
|
|
/**
|
|
* returns a list with no duplicates (like unix' "unique")
|
|
*/
|
|
function cleaned<type_element>(list: Array<type_element>, options?: {
|
|
collate_element?: ((x: type_element, y: type_element) => boolean);
|
|
}): Array<type_element>;
|
|
/**
|
|
* creates a binary partition of the list according to a given predicate
|
|
*/
|
|
function separate<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): type_separation<type_element>;
|
|
/**
|
|
*/
|
|
function clone<type_element>(list: Array<type_element>): Array<type_element>;
|
|
/**
|
|
*/
|
|
function reversed<type_element>(list: Array<type_element>): Array<type_element>;
|
|
/**
|
|
* @todo use Array.toSorted?
|
|
*/
|
|
function sorted<type_element>(list: Array<type_element>, options: {
|
|
compare_element?: ((element1: type_element, element2: type_element) => boolean);
|
|
}): Array<type_element>;
|
|
/**
|
|
* die Liste in gleich große Blöcke zerlegen
|
|
*/
|
|
function chop<type_element>(list: Array<type_element>, chunk_size: int): Array<Array<type_element>>;
|
|
/**
|
|
*/
|
|
function group<type_element>(list: Array<type_element>, collate_element: ((x: type_element, y: type_element) => boolean)): Array<Array<type_element>>;
|
|
/**
|
|
*/
|
|
function has<type_element>(list: Array<type_element>, predicate: ((element: type_element) => boolean)): boolean;
|
|
/**
|
|
* @deprecate use Array.includes or Array.some
|
|
*/
|
|
function contains<type_element>(list: Array<type_element>, element: type_element, options: {
|
|
collate_element?: ((element1: type_element, element2: type_element) => boolean);
|
|
}): boolean;
|
|
/**
|
|
* retrieves the element and its index of the list, which has the maximum value
|
|
*/
|
|
function max<type_element, type_value>(list: Array<type_element>, target_function: ((element: type_element) => type_value), options: {
|
|
compare_value: ((value1: type_value, value2: type_value) => boolean);
|
|
}): type_result_max<type_element, type_value>;
|
|
/**
|
|
* retrieves the element and its index of the list, which has the mininum value
|
|
*/
|
|
function min<type_element, type_value>(list: Array<type_element>, target_function: (element: type_element) => type_value, options: {
|
|
compare_value: ((value1: type_value, value2: type_value) => boolean);
|
|
}): type_result_max<type_element, type_value>;
|
|
/**
|
|
* implements the idea of arithmetic distribution like in "(a+b)·(c+d) = (a·c)+(a·d)+(b·c)+(b·d)"
|
|
* example: distribute([[1,2],[3],[4,5,6]]) = [[1,3,4],[1,3,5],[1,3,6],[2,3,4],[2,3,5],[2,3,6]]
|
|
*/
|
|
function distribute<type_element>(lists: Array<Array<type_element>>): Array<Array<type_element>>;
|
|
/**
|
|
*/
|
|
function contrast<type_left, type_right>(list_left: Array<type_left>, extract_key_left: ((left: type_left) => string), list_right: Array<type_right>, extract_key_right: ((right: type_right) => string)): {
|
|
both: Array<{
|
|
key: string;
|
|
left: type_left;
|
|
right: type_right;
|
|
}>;
|
|
only_left: Array<{
|
|
key: string;
|
|
left: type_left;
|
|
}>;
|
|
only_right: Array<{
|
|
key: string;
|
|
right: type_right;
|
|
}>;
|
|
};
|
|
}
|
|
declare namespace lib_plankton.conf {
|
|
/**
|
|
*/
|
|
type type_schema = ({
|
|
enum?: Array<any>;
|
|
default?: any;
|
|
description?: string;
|
|
} | {
|
|
type: "null";
|
|
description?: string;
|
|
} | {
|
|
type: "boolean";
|
|
nullable?: boolean;
|
|
enum?: Array<boolean>;
|
|
default?: boolean;
|
|
description?: string;
|
|
} | {
|
|
type: "integer";
|
|
nullable?: boolean;
|
|
enum?: Array<int>;
|
|
default?: int;
|
|
description?: string;
|
|
} | {
|
|
type: "number";
|
|
nullable?: boolean;
|
|
enum?: Array<number>;
|
|
default?: number;
|
|
description?: string;
|
|
} | {
|
|
type: "string";
|
|
nullable?: boolean;
|
|
enum?: Array<string>;
|
|
default?: string;
|
|
description?: string;
|
|
} | {
|
|
type: "array";
|
|
nullable?: boolean;
|
|
items: type_schema;
|
|
enum?: Array<Array<any>>;
|
|
default?: Array<any>;
|
|
description?: string;
|
|
} | {
|
|
type: "object";
|
|
nullable?: boolean;
|
|
properties?: Record<string, type_schema>;
|
|
required?: Array<string>;
|
|
additionalProperties?: (false | type_schema);
|
|
enum?: Array<Record<string, any>>;
|
|
default?: Record<string, any>;
|
|
description?: string;
|
|
} | {
|
|
anyOf: Array<type_schema>;
|
|
default?: any;
|
|
} | {
|
|
allOf: Array<type_schema>;
|
|
} | {
|
|
oneOf: Array<type_schema>;
|
|
} | {
|
|
not: type_schema;
|
|
});
|
|
/**
|
|
*/
|
|
type type_report = {
|
|
incident: string;
|
|
details: Record<string, any>;
|
|
};
|
|
/**
|
|
*/
|
|
type type_adaption<type_result> = {
|
|
reports: Array<type_report>;
|
|
result: lib_plankton.pod.type_pod<type_result>;
|
|
};
|
|
}
|
|
declare namespace lib_plankton.conf {
|
|
/**
|
|
* @todo versioning
|
|
*/
|
|
function refine<type_result>(schema: type_schema, value_raw: any): type_result;
|
|
/**
|
|
*/
|
|
function load(schema: type_schema, path: (null | string)): Promise<void>;
|
|
}
|
|
declare var plain_text_to_html: (text: string) => string;
|
|
/**
|
|
* @desc makes a valid
|
|
*/
|
|
declare var format_sentence: (str: string, rtl?: boolean, caseSense?: boolean) => string;
|
|
declare var fill_string_template: (template_string: string, object: any, fabric: Function, delimiter: string, default_string: string, sloppy: boolean) => string;
|
|
declare var make_string_template: (_template: string, _fabrics?: Object) => (object: {
|
|
[key: string]: string;
|
|
}) => string;
|
|
declare var make_eml_header: (object: {
|
|
[key: string]: string;
|
|
}) => string;
|
|
declare var make_eml_body: Object;
|
|
declare namespace lib_plankton.string {
|
|
/**
|
|
* @author neuc,frac
|
|
*/
|
|
function empty(str: string): boolean;
|
|
/**
|
|
* @desc returns a unique string
|
|
* @param {string} prefix an optional prefix for the generated string
|
|
* @return {string}
|
|
* @author fenris
|
|
*/
|
|
function generate(prefix?: string): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function join(parts: Array<string>, glue?: string): string;
|
|
/**
|
|
* @desc splits a string, but returns an empty list, if the string is empty
|
|
* @param {string} chain
|
|
* @param {string} separator
|
|
* @return {Array<string>}
|
|
* @author fenris
|
|
*/
|
|
function split(chain: string, separator?: string): Array<string>;
|
|
/**
|
|
* @author neu3no
|
|
*/
|
|
function explode(str: string, needle: string, max: int): Array<string>;
|
|
/**
|
|
* @desc concats a given word with itself n times
|
|
* @param {string} word
|
|
* @param {int}
|
|
* @return {string}
|
|
* @author fenris
|
|
*/
|
|
function repeat(word: string, count: int): string;
|
|
/**
|
|
* @desc lengthens a string by repeatedly appending or prepending another string
|
|
* @param {string} word the string to pad
|
|
* @param {int} length the length, which the result shall have
|
|
* @param {string} symbol the string, which will be added (multiple times)
|
|
* @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false
|
|
* @return {string} the padded string
|
|
* @author fenris
|
|
*/
|
|
function pad(word: string, length: int, symbol?: string, mode?: string): string;
|
|
/**
|
|
* @desc checks if a given string conttains a certain substring
|
|
* @param {string} string
|
|
* @param {string} part
|
|
* @return {boolean}
|
|
* @author fenris
|
|
*/
|
|
function contains(chain: string, part: string): boolean;
|
|
/**
|
|
* @desc checks if a given string starts with a certain substring
|
|
* @param {string} string
|
|
* @param {string} part
|
|
* @return {boolean}
|
|
* @author fenris
|
|
*/
|
|
function startsWith(chain: string, part: string): boolean;
|
|
/**
|
|
* @desc checks if a given string ends with a certain substring
|
|
* @param {string} string
|
|
* @param {string} part
|
|
* @return {boolean}
|
|
* @author fenris
|
|
*/
|
|
function endsWith(chain: string, part: string): boolean;
|
|
/**
|
|
* @desc count the occourrences of a string in a string
|
|
* @param string haystack_string the string wich should be examined
|
|
* @param string needle_string the string which should be counted
|
|
* @author neuc
|
|
*/
|
|
function count_occourrences(haystack_string: string, needle_string: string, check_escape: boolean): int;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function replace(str: string, replacements: Array<{
|
|
from: string;
|
|
to: string;
|
|
}>, options?: {}): string;
|
|
/**
|
|
* @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object
|
|
* @author fenris
|
|
*/
|
|
function coin(str: string, args: {
|
|
[id: string]: string;
|
|
}, options?: {
|
|
legacy?: boolean;
|
|
open?: string;
|
|
close?: string;
|
|
}): string;
|
|
/**
|
|
* @author fenris
|
|
* @deprecated use limit
|
|
*/
|
|
function cut(str: string, length: int, delimiter?: string): string;
|
|
/**
|
|
*/
|
|
function limit(str: string, options?: {
|
|
length?: int;
|
|
indicator?: string;
|
|
}): string;
|
|
/**
|
|
*/
|
|
function slice(str: string, size: int): Array<string>;
|
|
}
|
|
/**
|
|
* @deprecated
|
|
*/
|
|
declare namespace lib_string {
|
|
const empty: typeof lib_plankton.string.empty;
|
|
const generate: typeof lib_plankton.string.generate;
|
|
const split: typeof lib_plankton.string.split;
|
|
const explode: typeof lib_plankton.string.repeat;
|
|
const repeat: typeof lib_plankton.string.repeat;
|
|
const pad: typeof lib_plankton.string.pad;
|
|
const contains: typeof lib_plankton.string.contains;
|
|
const startsWith: typeof lib_plankton.string.startsWith;
|
|
const endsWith: typeof lib_plankton.string.endsWith;
|
|
const count_occourrences: typeof lib_plankton.string.count_occourrences;
|
|
const coin: typeof lib_plankton.string.coin;
|
|
const stance: typeof lib_plankton.string.coin;
|
|
const cut: typeof lib_plankton.string.cut;
|
|
}
|
|
declare namespace lib_plankton.string {
|
|
/**
|
|
* an implementation of c sprintf
|
|
* @param {string} string format string
|
|
* @param {array} args arguments which should be filled into
|
|
* @returns {string}
|
|
*/
|
|
var sprintf: (input: string, args?: Array<any>, original?: any) => string;
|
|
/**
|
|
* an implementation of c printf
|
|
* @param {string} string format string
|
|
* @param {array} args arguments which should be filled into
|
|
* @returns {string}
|
|
*/
|
|
function printf(format: any, args: any): void;
|
|
}
|
|
declare var sprintf: (input: string, args?: Array<any>, original?: any) => string;
|
|
declare var printf: typeof lib_plankton.string.printf;
|
|
declare var eml_log: any;
|
|
declare var track_exports: any;
|
|
declare var make_logger: (prefix: any, current_loglevel: any) => (obj: any, lvl: any) => void;
|
|
declare namespace lib_plankton.database {
|
|
/**
|
|
*/
|
|
type type_query = {
|
|
template: string;
|
|
arguments: Record<string, any>;
|
|
};
|
|
/**
|
|
*/
|
|
enum enum_type {
|
|
boolean = "boolean",
|
|
integer = "integer",
|
|
string_short = "string_short",
|
|
string_medium = "string_medium",
|
|
string_long = "string_long",
|
|
float = "float"
|
|
}
|
|
/**
|
|
*/
|
|
type type_description_create_table = {
|
|
name: string;
|
|
key_field?: (null | {
|
|
name: string;
|
|
type?: enum_type;
|
|
comment?: (null | string);
|
|
auto_increment?: (null | boolean);
|
|
description?: (null | string);
|
|
});
|
|
data_fields?: Array<{
|
|
name: string;
|
|
nullable?: boolean;
|
|
type: enum_type;
|
|
default?: any;
|
|
description?: (null | string);
|
|
}>;
|
|
constraints?: Array<{
|
|
kind: string;
|
|
parameters?: Record<string, any>;
|
|
}>;
|
|
description?: (null | string);
|
|
};
|
|
/**
|
|
*/
|
|
type type_description_insert = {
|
|
table_name: string;
|
|
values: Record<string, any>;
|
|
returning?: (null | string);
|
|
};
|
|
/**
|
|
*/
|
|
type type_description_update = {
|
|
table_name: string;
|
|
values: Record<string, any>;
|
|
condition?: (null | string);
|
|
arguments?: (null | Record<string, any>);
|
|
};
|
|
/**
|
|
*/
|
|
type type_description_delete = {
|
|
table_name: string;
|
|
condition?: (null | string);
|
|
arguments?: (null | Record<string, any>);
|
|
};
|
|
/**
|
|
*/
|
|
type type_description_select = {
|
|
source: string;
|
|
fields?: (null | Array<string>);
|
|
condition?: (null | string);
|
|
group_by?: (null | string);
|
|
having?: (null | string);
|
|
order_by?: (null | string);
|
|
limit?: (null | int);
|
|
arguments?: (null | Record<string, any>);
|
|
};
|
|
/**
|
|
* rows
|
|
*/
|
|
type type_result_get = Array<Record<string, any>>;
|
|
/**
|
|
* auto insert id
|
|
*/
|
|
type type_result_put = (null | int);
|
|
/**
|
|
* number of affected rows
|
|
*/
|
|
type type_result_set = int;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_database = {
|
|
wrap_name: ((name: string) => string);
|
|
query_free_get: ((query: type_query) => Promise<type_result_get>);
|
|
query_free_put: ((query: type_query) => Promise<type_result_put>);
|
|
query_free_set: ((query: type_query) => Promise<type_result_set>);
|
|
query_create_table: ((description_create_table: type_description_create_table) => Promise<void>);
|
|
query_insert: ((description_insert: type_description_insert) => Promise<type_result_put>);
|
|
query_update: ((description_update: type_description_update) => Promise<type_result_set>);
|
|
query_delete: ((description_delete: type_description_delete) => Promise<type_result_set>);
|
|
query_select: ((description_select: type_description_select) => Promise<type_result_get>);
|
|
};
|
|
/**
|
|
*/
|
|
type interface_database = database.type_database;
|
|
}
|
|
declare namespace lib_plankton.storage {
|
|
/**
|
|
* implements the idea of a database, which houses datasets (type_value) and manages their access by ids or sth. similar (type_key)
|
|
*
|
|
* @author fenris
|
|
*/
|
|
type type_store<type_key, type_value, type_setup_input, type_searchterm, type_preview> = {
|
|
/**
|
|
* shall prepare the storage instance for use
|
|
*
|
|
* @author fenris
|
|
*/
|
|
setup(input: type_setup_input): Promise<void>;
|
|
/**
|
|
* shall insert a new dataset and return its automatically assign key
|
|
*
|
|
* @author fenris
|
|
*/
|
|
create(value: type_value): Promise<type_key>;
|
|
/**
|
|
* shall modify an existing dataset
|
|
*
|
|
* @author fenris
|
|
*/
|
|
update(key: type_key, value: type_value): Promise<void>;
|
|
/**
|
|
* shall remove an existing dataset
|
|
*
|
|
* @author fenris
|
|
*/
|
|
delete(key: type_key): Promise<void>;
|
|
/**
|
|
* shall get an existing dataset by its key
|
|
*
|
|
* @author fenris
|
|
*/
|
|
read(key: type_key): Promise<type_value>;
|
|
/**
|
|
* shall list keys and previews of existing datasets, which match a certain search term
|
|
*
|
|
* @author fenris
|
|
*/
|
|
search(term?: (null | type_searchterm)): Promise<Array<{
|
|
key: type_key;
|
|
preview: type_preview;
|
|
}>>;
|
|
};
|
|
/**
|
|
* for class wrappers
|
|
*/
|
|
type interface_store<type_key, type_value, type_setup_input, type_searchterm, type_preview> = type_store<type_key, type_value, type_setup_input, type_searchterm, type_preview>;
|
|
}
|
|
declare namespace lib_plankton.storage {
|
|
/**
|
|
* implements the idea of a storage without managed keys
|
|
*
|
|
* @author fenris
|
|
*/
|
|
type type_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview> = {
|
|
/**
|
|
* shall prepare the storage instance for use
|
|
*
|
|
* @author fenris
|
|
*/
|
|
setup(input: type_setup_input): Promise<void>;
|
|
/**
|
|
* shall remove all items
|
|
*/
|
|
clear(): Promise<void>;
|
|
/**
|
|
* shall insert a new or modify an existing dataset and return whether it is new
|
|
*
|
|
* @author fenris
|
|
*/
|
|
write(key: type_key, value: type_value): Promise<boolean>;
|
|
/**
|
|
* shall remove an existing dataset
|
|
*
|
|
* @author fenris
|
|
*/
|
|
delete(key: type_key): Promise<void>;
|
|
/**
|
|
* shall get an existing dataset by its key
|
|
*
|
|
* @author fenris
|
|
*/
|
|
read(key: type_key): Promise<type_value>;
|
|
/**
|
|
* shall list keys and previews of existing datasets, which match a certain search term
|
|
*
|
|
* @author fenris
|
|
*/
|
|
search(term?: (null | type_searchterm)): Promise<Array<{
|
|
key: type_key;
|
|
preview: type_preview;
|
|
}>>;
|
|
};
|
|
/**
|
|
* for class wrappers
|
|
*/
|
|
type interface_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview> = type_chest<type_key, type_value, type_setup_input, type_searchterm, type_preview>;
|
|
}
|
|
declare namespace lib_plankton.storage.memory {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_subject<type_value> = {
|
|
data: Record<string, type_value>;
|
|
};
|
|
/**
|
|
*/
|
|
type type_parameters<type_value> = {};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function make<type_value>(parameters: type_parameters<type_value>): type_subject<type_value>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function clear<type_value>(subject: type_subject<type_value>): void;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function write<type_value>(subject: type_subject<type_value>, key: string, value: type_value): boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function delete_<type_value>(subject: type_subject<type_value>, key: string): void;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function read<type_value>(subject: type_subject<type_value>, key: string): type_value;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function list<type_value>(subject: type_subject<type_value>): Array<string>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function search<type_value>(subject: type_subject<type_value>, term: (null | string)): Array<{
|
|
key: string;
|
|
preview: string;
|
|
}>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function implementation_chest<type_value>(parameters: type_parameters<type_value>): type_chest<string, type_value, void, string, string>;
|
|
}
|
|
declare namespace lib_plankton.storage.memory {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_chest<type_item> implements type_chest<string, type_item, void, string, string> {
|
|
private subject;
|
|
constructor(parameters: type_parameters<type_item>);
|
|
setup(input: any): Promise<void>;
|
|
clear(): Promise<void>;
|
|
write(key: any, value: any): Promise<boolean>;
|
|
delete(key: any): Promise<void>;
|
|
read(key: any): Promise<Awaited<type_item>>;
|
|
search(term: any): Promise<{
|
|
key: string;
|
|
preview: string;
|
|
}[]>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.storage.localstorage {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_subject = {
|
|
corner: string;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_parameters = {
|
|
corner?: string;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function make(parameters: type_parameters): type_subject;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function clear(subject: type_subject): void;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function write(subject: type_subject, key: string, item: string): boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function delete_(subject: type_subject, key: string): void;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function read(subject: type_subject, key: string): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function list(subject: type_subject): Array<string>;
|
|
/**
|
|
*/
|
|
function implementation_chest(parameters: type_parameters): type_chest<string, string, void, string, string>;
|
|
}
|
|
declare namespace lib_plankton.storage.localstorage {
|
|
/**
|
|
* uses the browsers localstorage as chest
|
|
*
|
|
* @author fenris
|
|
*/
|
|
class class_chest implements type_chest<string, string, string, string, any> {
|
|
private subject;
|
|
constructor(parameters: type_parameters);
|
|
setup(input: any): Promise<void>;
|
|
clear(): Promise<void>;
|
|
write(key: any, value: any): Promise<boolean>;
|
|
delete(key: any): Promise<void>;
|
|
read(key: any): Promise<string>;
|
|
search(term: any): Promise<{
|
|
key: string;
|
|
preview: string;
|
|
}[]>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.map {
|
|
/**
|
|
*/
|
|
type type_pair<type_key, type_value> = {
|
|
key: type_key;
|
|
value: type_value;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_map<type_key, type_value> = {
|
|
size: (() => int);
|
|
has: ((key: type_key) => boolean);
|
|
get: ((key: type_key, fallback?: lib_plankton.pod.type_pod<type_value>) => type_value);
|
|
set: ((key: type_key, value: type_value) => void);
|
|
delete: ((key: type_key) => void);
|
|
iterate: ((procedure: ((value: type_value, key?: type_key) => void)) => void);
|
|
};
|
|
}
|
|
declare namespace lib_plankton.map {
|
|
/**
|
|
*/
|
|
function clear<type_key, type_value>(map: type_map<type_key, type_value>): void;
|
|
/**
|
|
*/
|
|
function keys<type_key, type_value>(map: type_map<type_key, type_value>): Array<type_key>;
|
|
/**
|
|
*/
|
|
function values<type_key, type_value>(map: type_map<type_key, type_value>): Array<type_value>;
|
|
/**
|
|
*/
|
|
function dump<type_key, type_value>(map: type_map<type_key, type_value>): Array<type_pair<type_key, type_value>>;
|
|
/**
|
|
*/
|
|
function show<type_key, type_value>(map: type_map<type_key, type_value>, options?: {
|
|
show_key?: ((key: type_key) => string);
|
|
show_value?: ((value: type_value) => string);
|
|
}): string;
|
|
}
|
|
declare namespace lib_plankton.map.simplemap {
|
|
/**
|
|
*/
|
|
type type_subject<type_value> = {
|
|
data: Record<string, type_value>;
|
|
};
|
|
/**
|
|
*/
|
|
function make<type_value>(options?: {
|
|
data?: Record<string, type_value>;
|
|
}): type_subject<type_value>;
|
|
/**
|
|
*/
|
|
function size<type_value>(subject: type_subject<type_value>): int;
|
|
/**
|
|
*/
|
|
function has<type_value>(subject: type_subject<type_value>, key: string): boolean;
|
|
/**
|
|
*/
|
|
function get_safe<type_value>(subject: type_subject<type_value>, key: string): lib_plankton.pod.type_pod<type_value>;
|
|
/**
|
|
*/
|
|
function get<type_value>(subject: type_subject<type_value>, key: string, fallback?: lib_plankton.pod.type_pod<type_value>): type_value;
|
|
/**
|
|
*/
|
|
function set<type_value>(subject: type_subject<type_value>, key: string, value: type_value): void;
|
|
/**
|
|
*/
|
|
function delete_<type_value>(subject: type_subject<type_value>, key: string): void;
|
|
/**
|
|
*/
|
|
function iterate<type_value>(subject: type_subject<type_value>, procedure: ((value?: type_value, key?: string) => void)): void;
|
|
/**
|
|
*/
|
|
function implementation_map<type_value>(subject: type_subject<type_value>): type_map<string, type_value>;
|
|
}
|
|
declare namespace lib_plankton.map.hashmap {
|
|
/**
|
|
* we base the hashmap on a simplemap, whos keys are the hashes and whos values are the key/value-pairs
|
|
*/
|
|
type type_subject<type_key, type_value> = {
|
|
hashing: ((key: type_key) => string);
|
|
core: lib_plankton.map.simplemap.type_subject<type_pair<type_key, type_value>>;
|
|
};
|
|
/**
|
|
*/
|
|
function make<type_key, type_value>(hashing: ((key: type_key) => string), options?: {
|
|
pairs?: Array<type_pair<type_key, type_value>>;
|
|
}): type_subject<type_key, type_value>;
|
|
/**
|
|
*/
|
|
function size<type_key, type_value>(subject: type_subject<type_key, type_value>): int;
|
|
/**
|
|
*/
|
|
function has<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): boolean;
|
|
/**
|
|
*/
|
|
function get<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, fallback?: lib_plankton.pod.type_pod<type_value>): type_value;
|
|
/**
|
|
*/
|
|
function set<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, value: type_value): void;
|
|
/**
|
|
*/
|
|
function delete_<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): void;
|
|
/**
|
|
*/
|
|
function iterate<type_key, type_value>(subject: type_subject<type_key, type_value>, procedure: ((value?: type_value, key?: type_key) => void)): void;
|
|
/**
|
|
*/
|
|
function implementation_map<type_key, type_value>(subject: type_subject<type_key, type_value>): type_map<type_key, type_value>;
|
|
}
|
|
declare namespace lib_plankton.map.collatemap {
|
|
/**
|
|
*/
|
|
type type_collation<type_key> = ((key1: type_key, key2: type_key) => boolean);
|
|
/**
|
|
*/
|
|
export type type_subject<type_key, type_value> = {
|
|
collation: type_collation<type_key>;
|
|
pairs: Array<type_pair<type_key, type_value>>;
|
|
};
|
|
/**
|
|
*/
|
|
export function make<type_key, type_value>(collation: type_collation<type_key>, options?: {
|
|
pairs?: Array<type_pair<type_key, type_value>>;
|
|
}): type_subject<type_key, type_value>;
|
|
/**
|
|
*/
|
|
export function size<type_key, type_value>(subject: type_subject<type_key, type_value>): int;
|
|
/**
|
|
*/
|
|
export function has<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): boolean;
|
|
/**
|
|
* @todo use .find
|
|
*/
|
|
export function get<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, fallback?: lib_plankton.pod.type_pod<type_value>): type_value;
|
|
/**
|
|
*/
|
|
export function set<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key, value: type_value): void;
|
|
/**
|
|
*/
|
|
export function delete_<type_key, type_value>(subject: type_subject<type_key, type_value>, key: type_key): void;
|
|
/**
|
|
*/
|
|
export function iterate<type_key, type_value>(subject: type_subject<type_key, type_value>, function_: ((value?: type_value, key?: type_key) => void)): void;
|
|
/**
|
|
*/
|
|
export function implementation_map<type_key, type_value>(subject: type_subject<type_key, type_value>): type_map<type_key, type_value>;
|
|
export {};
|
|
}
|
|
declare namespace lib_plankton.complex {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_complex = {
|
|
rea: float;
|
|
ima: float;
|
|
};
|
|
/**
|
|
* erstellt eine komplexe Zahl anhand ihrer kartesianischen Koordinaten
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function make_cartesian(rea_: float, ima_: float): type_complex;
|
|
/**
|
|
* erstellt eine komplexe Zahl anhand ihrer Polar-Koordinaten
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function make_polar(abs: float, arg: float): type_complex;
|
|
/**
|
|
* alias zu "make_cartesian"
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function make(rea_: float, ima_: float): type_complex;
|
|
/**
|
|
* erstellt die komplexe Null
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function nul(): type_complex;
|
|
/**
|
|
* erstellt die komplexe Eins
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function one(): type_complex;
|
|
/**
|
|
* gibt den Real-Teil einer komplexen Zahl zurück
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function rea(x: type_complex): float;
|
|
/**
|
|
* gibt den Imaginär-Teil einer komplexen Zahl zurück
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function ima(x: type_complex): float;
|
|
/**
|
|
* gibt die konjugierte komplexe Zahl zurück
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function con(x: type_complex): type_complex;
|
|
/**
|
|
* gibt den Betrag einer komplexen Zahl zurück
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function abs(x: type_complex): float;
|
|
/**
|
|
* gibt das Argument einer komplexen Zahl zurück (auf dem Hauptzweig des komplexen Logarithmus)
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function arg(x: type_complex): float;
|
|
/**
|
|
* gibt eine skalierte komplexe Zahl zurück (das Produkt mit einer reellen Zahl)
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function scl(x: type_complex, s: float): type_complex;
|
|
/**
|
|
* errechnet die Summe zweier komplexer Zahl
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function add(x: type_complex, y: type_complex): type_complex;
|
|
/**
|
|
* gibt die additiv inverse, also negierte komplexe Zahl zurück
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function neg(x: type_complex): type_complex;
|
|
/**
|
|
* ermittelt die Differenz zweier komplexer Zahlen
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function sub(x: type_complex, y: type_complex): type_complex;
|
|
/**
|
|
* ermittelt das Produkt zweier komplexer Zahlen
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function mul(x: type_complex, y: type_complex): type_complex;
|
|
/**
|
|
* ermittelt die multiplikativ inverse komplexe Zahl, also den Kehrwert
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function inv(x: type_complex): type_complex;
|
|
/**
|
|
* ermittelt den Quotienten zweier komplexer Zahlen
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function div(x: type_complex, y: type_complex): type_complex;
|
|
/**
|
|
* ermittelt die natürliche Potenz einer komplexen Zahl
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function npow(x: type_complex, n: int): type_complex;
|
|
/**
|
|
* ermittelt die natürliche Potenz einer komplexen Zahl
|
|
*
|
|
* @author fenris
|
|
* @deprecated use "npow" instead
|
|
* @todo remove
|
|
*/
|
|
function exp(x: type_complex, n: int): type_complex;
|
|
/**
|
|
* ermittelt die Potenz zweier komplexer Zahlen
|
|
*
|
|
* @author fenris
|
|
* @todo Probleme der komplexen Exponentiation berücksichtigen
|
|
*/
|
|
function pow(x: type_complex, y: type_complex): type_complex;
|
|
/**
|
|
* gibt die n-ten komplexen Einheits-Wurzeln zurück ({x ∈ C | x^n = 1})
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function unitroots(n: int): Array<type_complex>;
|
|
/**
|
|
* {x ∈ C | x^n = y}
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function normroots(n: int, y: type_complex): Array<type_complex>;
|
|
/**
|
|
* ermittelt ob zwei komplexe Zahlen gleich sind
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function equ(x: type_complex, y: type_complex, threshold?: float): boolean;
|
|
/**
|
|
* gibt eine textuelle Repräsentation einer komplexen Zahl zurück
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function str(x: type_complex): string;
|
|
}
|
|
declare namespace lib_plankton.complex {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_complex {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
private subject;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
private constructor();
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
private static _cram;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
private static _tear;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static make_cartesian(rea: float, ima: float): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static make_polar(abs: float, arg: float): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static make(rea: float, ima: float): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static nul(): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static one(): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
con(): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
abs(): float;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
arg(): float;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
scl(s: float): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
add(other: class_complex): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
neg(): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
sub(other: class_complex): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
mul(other: class_complex): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
inv(): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
div(other: class_complex): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
exp(n: int): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
pow(other: class_complex): class_complex;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
equ(other: class_complex): boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
str(): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
toString(): string;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.math {
|
|
/**
|
|
* @desc golden ratio (e.g. for generating colors)
|
|
* @author fenris
|
|
*/
|
|
const phi: float;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
const e: float;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
const pi: float;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
const tau: float;
|
|
}
|
|
declare namespace lib_plankton.math {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function clamp(x: number, a?: number, b?: number): number;
|
|
/**
|
|
* @desc the mathematical sign-function
|
|
* @return {int} an element of {-1,0,+1}
|
|
* @author fenris
|
|
*/
|
|
function sgn(x: number): int;
|
|
/**
|
|
* @desc integer division
|
|
* @author fenris
|
|
*/
|
|
function div(x: float, y: float): float;
|
|
/**
|
|
* @desc real modulo operator
|
|
* @author fenris
|
|
*/
|
|
function mod(x: float, y: float): float;
|
|
/**
|
|
* @desc computes "x^y mod z" via square-and-multiply
|
|
* @param {int} base ("x")
|
|
* @param {int} exponent ("y")
|
|
* @param {int} modulus ("z")
|
|
* @return {int}
|
|
* @author fenris
|
|
* @todo handle invalid cases (e.g. "z < 1")
|
|
* @todo implement iteratively
|
|
*/
|
|
function modpow(base: int, exponent: int, modulus: int): int;
|
|
/**
|
|
* @desc determines if two integers are coprime, i.e. that they don't have a common divisor greater than 1
|
|
* @author fenris
|
|
* @todo write function "gcdx" and base on it
|
|
*/
|
|
function coprime(x: int, y: int): boolean;
|
|
/**
|
|
* @desc extended euclidean algorithm for computing multiplicative inverse elements
|
|
* @param {int} modulus
|
|
* @param {int} element
|
|
* @author fenris
|
|
* @todo write function "gcdx" and base on it
|
|
* @todo handle more invalid cases
|
|
*/
|
|
function inv(modulus: int, element: int, positive?: boolean): int;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function interpolate_linear(x: number, y: number, t?: number): number;
|
|
/**
|
|
* @desc kind of the inverse of linear interpolation; i.e. to find the coefficient "t" for given values x, y and
|
|
* their presumed interpolation v
|
|
* @author fenris
|
|
*/
|
|
function appoint_linear(x: number, y: number, v: number): number;
|
|
/**
|
|
* continued fraction decomposition
|
|
*/
|
|
function cfd(x: float, n?: int): Array<int>;
|
|
}
|
|
declare namespace lib_plankton.math {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_relationparameters<type_value> = {
|
|
symbol?: string;
|
|
name?: string;
|
|
predicate?: (value: type_value, reference: type_value) => boolean;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_relation<type_value> implements interface_showable, interface_hashable, interface_collatable<class_relation<type_value>> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected id: string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected symbol: string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected name: string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected predicate: (value: type_value, reference: type_value) => boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
check(value: type_value, reference: type_value): boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(id: string, { "symbol": symbol, "name": name, "predicate": predicate, }: type_relationparameters<type_value>);
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
id_get(): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
symbol_get(): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
name_get(): string;
|
|
/**
|
|
* @desc [accessor] [implementation]
|
|
* @author fenris
|
|
*/
|
|
_show(): string;
|
|
/**
|
|
* @desc [accessor] [implementation]
|
|
* @author fenris
|
|
*/
|
|
_hash(): string;
|
|
/**
|
|
* @desc [accessor] [implementation]
|
|
* @author fenris
|
|
*/
|
|
_collate(relation: class_relation<type_value>): boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
toString(): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected static pool<type_value>(): {
|
|
[id: string]: type_relationparameters<type_value>;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static get<type_value>(id: string): class_relation<type_value>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
static available(): Array<string>;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_filtrationitem<type_value> implements interface_showable {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected extract: (dataset: Object) => type_value;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected relation: class_relation<type_value>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected reference: type_value;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor({ "extract": extract, "relation": relation, "reference": reference, }: {
|
|
extract: (dataset: Object) => type_value;
|
|
relation: class_relation<type_value>;
|
|
reference: type_value;
|
|
});
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
check(dataset: Object): boolean;
|
|
/**
|
|
* @desc [implementation]
|
|
* @author fenris
|
|
*/
|
|
_show(): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
toString(): string;
|
|
}
|
|
/**
|
|
* @desc disjunctive normal form
|
|
* @author fenris
|
|
*/
|
|
class class_filtration implements interface_showable {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected clauses: Array<Array<class_filtrationitem<any>>>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(clauses: Array<Array<class_filtrationitem<any>>>);
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
check(dataset: Object): boolean;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
use(datasets: Array<Object>): Array<Object>;
|
|
/**
|
|
* @desc [implementation]
|
|
* @author fenris
|
|
*/
|
|
_show(): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
toString(): string;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
* @deprecated
|
|
*/
|
|
function comparator_to_relation<type_value>(comparator: (x: type_value, y: type_value) => int): (x: type_value, y: type_value) => boolean;
|
|
/**
|
|
* @author fenris
|
|
* @deprecated
|
|
*/
|
|
function relation_to_comparator<type_value>(relation: (x: type_value, y: type_value) => boolean): (x: type_value, y: type_value) => int;
|
|
}
|
|
declare module lib_calculus {
|
|
/**
|
|
* @class Calculus
|
|
* @desc Ensure precision of mathematical operations
|
|
*/
|
|
class Calculus {
|
|
/** @desc only for typescript
|
|
*/
|
|
private NORM;
|
|
/**
|
|
* @constructor
|
|
* @þaram {number} norm
|
|
*/
|
|
constructor(norm?: number);
|
|
/**
|
|
* normalize
|
|
* @param {number} value
|
|
* @return {number}
|
|
*/
|
|
normalize(value: number): number;
|
|
/**
|
|
* denormalize
|
|
* @param {number} value
|
|
* @return {number}
|
|
*/
|
|
denormalize(value: number): number;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.math {
|
|
/**
|
|
* {x ∈ C | 0 = ax³ + bx² + cx + d}
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function cubic_solve(a: lib_plankton.complex.type_complex, b: lib_plankton.complex.type_complex, c: lib_plankton.complex.type_complex, d: lib_plankton.complex.type_complex): Array<lib_plankton.complex.type_complex>;
|
|
/**
|
|
* {x ∈ C | 0 = ax³ + bx² + cx + d}
|
|
*
|
|
* @author fenris
|
|
*/
|
|
function cubic_solve_real(a: float, b: float, c: float, d: float): Array<lib_plankton.complex.type_complex>;
|
|
}
|
|
declare namespace lib_plankton.color {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_model_hsv = {
|
|
hue: float;
|
|
saturation: float;
|
|
value: float;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_model_hsl = {
|
|
hue: float;
|
|
saturation: float;
|
|
lightness: float;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_model_rgb = {
|
|
red: float;
|
|
green: float;
|
|
blue: float;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_color = {
|
|
model: type_model_rgb;
|
|
};
|
|
}
|
|
declare namespace lib_plankton.color {
|
|
/**
|
|
*/
|
|
function make_hsv({ "hue": hue, "saturation": saturation, "value": value }: {
|
|
hue?: float;
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function make_hsl(model_hsl: type_model_hsl): type_color;
|
|
/**
|
|
*/
|
|
function make_rgb(model_rgb: type_model_rgb): type_color;
|
|
/**
|
|
*/
|
|
function to_hsv(color: type_color): type_model_hsv;
|
|
/**
|
|
*/
|
|
function to_hsl(color: type_color): type_model_hsl;
|
|
/**
|
|
*/
|
|
function to_rgb(color: type_color): type_model_rgb;
|
|
/**
|
|
*/
|
|
function to_cmyk(color: type_color): type_model_rgb;
|
|
/**
|
|
*/
|
|
function add(color1: type_color, color2: type_color): type_color;
|
|
/**
|
|
*/
|
|
function multiply(color1: type_color, color2: type_color): type_color;
|
|
/**
|
|
* @todo blend through other model?
|
|
*/
|
|
function blend(color1: type_color, color2: type_color, strength?: float): type_color;
|
|
/**
|
|
*/
|
|
function mix(color1: type_color, color2: type_color, { "strength1": option_strength1, "strength2": option_strength2, }?: {
|
|
strength1?: float;
|
|
strength2?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function output_rgb(color: type_color): string;
|
|
/**
|
|
*/
|
|
function output_hex(color: type_color): string;
|
|
/**
|
|
*/
|
|
function output_dot(color: type_color): string;
|
|
/**
|
|
*/
|
|
function give_generic(n: int, { "offset": option_offset, "saturation": option_saturation, "value": option_value, }: {
|
|
offset?: float;
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function give_gray({ "value": option_value, }: {
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function give_black(): type_color;
|
|
/**
|
|
*/
|
|
function give_white(): type_color;
|
|
/**
|
|
*/
|
|
function give_red({ "saturation": option_saturation, "value": option_value, }?: {
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function give_green({ "saturation": option_saturation, "value": option_value, }?: {
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function give_blue({ "saturation": option_saturation, "value": option_value, }?: {
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function give_yellow({ "saturation": option_saturation, "value": option_value, }?: {
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function give_cyan({ "saturation": option_saturation, "value": option_value, }?: {
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
/**
|
|
*/
|
|
function give_magenta({ "saturation": option_saturation, "value": option_value, }?: {
|
|
saturation?: float;
|
|
value?: float;
|
|
}): type_color;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
declare namespace lib_plankton.xml {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
abstract class class_node {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
abstract compile(depth?: int): string;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_node_text extends class_node {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected content: string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(content: string);
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
compile(depth?: int): string;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_node_comment extends class_node {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected content: string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(content: string);
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
compile(depth?: int): string;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_node_complex extends class_node {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected name: string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected attributes: {
|
|
[key: string]: string;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
protected children: Array<class_node>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor(name: string, attributes?: {
|
|
[key: string]: string;
|
|
}, children?: any[]);
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
compile(depth?: int): string;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.http {
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
enum enum_method {
|
|
options = "options",
|
|
head = "head",
|
|
get = "get",
|
|
delete = "delete",
|
|
post = "post",
|
|
put = "put",
|
|
patch = "patch"
|
|
}
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
type type_request = {
|
|
scheme: ("http" | "https");
|
|
host: (null | string);
|
|
path: string;
|
|
version: string;
|
|
method: enum_method;
|
|
query: (null | string);
|
|
headers: Record<string, string>;
|
|
body: (null | Buffer);
|
|
};
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
type type_response = {
|
|
version: (null | string);
|
|
status_code: int;
|
|
headers: Record<string, string>;
|
|
body: Buffer;
|
|
};
|
|
}
|
|
declare namespace lib_plankton.http {
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
function encode_method(method: enum_method): string;
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
function encode_request(request: type_request): string;
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
function decode_request(request_raw: string): type_request;
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
function encode_response(response: type_response): string;
|
|
/**
|
|
* @author fenris <frass@greenscale.de>
|
|
*/
|
|
function decode_response(response_raw: string): type_response;
|
|
/**
|
|
* executes an HTTP request
|
|
*
|
|
* @todo define type_signal
|
|
*/
|
|
function call(request: type_request, options?: {
|
|
timeout?: (null | float);
|
|
follow_redirects?: boolean;
|
|
implementation?: ("fetch" | "http_module");
|
|
}): Promise<type_response>;
|
|
}
|
|
declare namespace lib_plankton.http {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_http_request implements lib_plankton.code.interface_code<type_request, string> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor();
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(x: type_request): string;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(x: string): type_request;
|
|
}
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_http_response implements lib_plankton.code.interface_code<type_response, string> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor();
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(x: type_response): string;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(x: string): type_response;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.url {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_url = {
|
|
scheme: (null | string);
|
|
host: (null | string);
|
|
username: (null | string);
|
|
password: (null | string);
|
|
port: (null | int);
|
|
path: (null | string);
|
|
query: (null | string);
|
|
hash: (null | string);
|
|
};
|
|
}
|
|
declare namespace lib_plankton.url {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function encode(url: type_url): string;
|
|
/**
|
|
* @author fenris
|
|
* @todo arguments
|
|
*/
|
|
function decode(url_raw: string): type_url;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function implementation_code(): lib_plankton.code.type_code<type_url, string>;
|
|
}
|
|
declare namespace lib_plankton.url {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_url implements lib_plankton.code.interface_code<type_url, string> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor();
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(x: any): string;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(x: string): any;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.www_form {
|
|
/**
|
|
*/
|
|
type type_source = Record<string, string>;
|
|
/**
|
|
*/
|
|
type type_target = string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function encode(source: type_source): type_target;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function decode(target: type_target): type_source;
|
|
}
|
|
declare namespace lib_plankton.www_form {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_www_form implements lib_plankton.code.interface_code<type_source, type_target> {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
constructor();
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
encode(source: type_source): type_target;
|
|
/**
|
|
* @implementation
|
|
* @author fenris
|
|
*/
|
|
decode(target: type_target): type_source;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.translate {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_package_meta = {
|
|
identifier: string;
|
|
name?: string;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
type type_package = {
|
|
meta: type_package_meta;
|
|
tree: {
|
|
[id: string]: string;
|
|
};
|
|
};
|
|
/**
|
|
* @desc the level of verbosity, specifiying how much output the system shall provide about its actions
|
|
* @author fenris
|
|
*/
|
|
var _verbosity: int;
|
|
/**
|
|
* @desc moves a language to the top of the order, making it the primary one
|
|
* @author fenris
|
|
*/
|
|
function promote(identifier: string): void;
|
|
/**
|
|
* @desc adds a package to the sytem
|
|
* @author fenris
|
|
*/
|
|
function add(package_: type_package): void;
|
|
/**
|
|
* @desc integrates a package to the system, i.e. creates a new one if none existed so far or merges with an existing one
|
|
* @author fenris
|
|
*/
|
|
function feed(package_: type_package): void;
|
|
/**
|
|
* @desc tries to retrieve a translation for a specific package identifier
|
|
* @author fenris
|
|
*/
|
|
function fetch(identifier: string, path: string, args?: {
|
|
[id: string]: string;
|
|
}): lib_plankton.pod.type_pod<string>;
|
|
/**
|
|
* @desc retrieves a string by going through the order and trying to fetch it for the current entry
|
|
* @author fenris
|
|
*/
|
|
function get(path: string, args?: {
|
|
[id: string]: string;
|
|
}, fallback?: string): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function list(): Array<type_package_meta>;
|
|
/**
|
|
* @author fenris
|
|
* @todo get rid of this; it's currenly needed only for the cdh-internal lib_completion
|
|
*/
|
|
function paths(): Array<string>;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function initialize({ "logprefix": logprefix, "verbosity": verbosity, "packages": packages, "order": order, "autopromote": autopromote, }?: {
|
|
logprefix?: string;
|
|
verbosity?: int;
|
|
packages?: Array<type_package>;
|
|
order?: Array<string>;
|
|
autopromote?: boolean;
|
|
}): Promise<void>;
|
|
}
|
|
declare namespace lib_plankton.translate {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function iso_639_1_to_iso_639_2(iso6391: string): string;
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
function stance(str: string): string;
|
|
}
|
|
declare namespace lib_plankton.zoo_page {
|
|
/**
|
|
*/
|
|
export type type_location = {
|
|
name: string;
|
|
parameters: Record<string, any>;
|
|
};
|
|
/**
|
|
*/
|
|
type type_handler = ((parameters: Record<string, any>, target_element: Element) => void);
|
|
/**
|
|
*/
|
|
export let _pool: Record<string, type_handler>;
|
|
/**
|
|
*/
|
|
export function encode(location: type_location): string;
|
|
/**
|
|
*/
|
|
export function add_nav_entry(location: type_location, options?: {
|
|
label?: (null | string);
|
|
}): void;
|
|
/**
|
|
* encodes a location in the URL and loads it
|
|
*/
|
|
export function set(location: type_location): void;
|
|
/**
|
|
*/
|
|
export function register(location_name: string, handler: type_handler, options?: {}): void;
|
|
/**
|
|
*/
|
|
export function init(target_element: Element, options?: {
|
|
pool?: Record<string, type_handler>;
|
|
fallback?: (null | type_location);
|
|
}): void;
|
|
/**
|
|
*/
|
|
export function start(): void;
|
|
export {};
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
interface interface_input<type_value> {
|
|
/**
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
*/
|
|
read(): Promise<type_value>;
|
|
/**
|
|
*/
|
|
write(value: type_value): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_wrapped<type_value_inner, type_value_outer> implements interface_input<type_value_outer> {
|
|
/**
|
|
*/
|
|
private core;
|
|
/**
|
|
*/
|
|
private wrap;
|
|
/**
|
|
*/
|
|
private unwrap;
|
|
/**
|
|
*/
|
|
constructor(core: interface_input<type_value_inner>, wrap: ((value_inner: type_value_inner) => type_value_outer), unwrap: ((value_outer: type_value_outer) => type_value_inner), options?: {});
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<type_value_outer>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: type_value_outer): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_soft<type_value_core> implements interface_input<(null | type_value_core)> {
|
|
/**
|
|
*/
|
|
private core;
|
|
/**
|
|
*/
|
|
private dom_set;
|
|
/**
|
|
*/
|
|
private dom_wrapper;
|
|
/**
|
|
*/
|
|
constructor(core: interface_input<type_value_core>, options?: {});
|
|
/**
|
|
*/
|
|
private toggle;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<(null | type_value_core)>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: (null | type_value_core)): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_hidden implements interface_input<any> {
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
private value;
|
|
/**
|
|
*/
|
|
constructor(options?: {
|
|
initial_value?: any;
|
|
});
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<any>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: any): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
* @todo abstract
|
|
*/
|
|
class class_input_text implements interface_input<string> {
|
|
/**
|
|
*/
|
|
private read_only;
|
|
/**
|
|
*/
|
|
private pattern;
|
|
/**
|
|
*/
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
constructor(options?: {
|
|
read_only?: boolean;
|
|
pattern?: (null | string);
|
|
});
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<string>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: string): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_email implements interface_input<string> {
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
constructor();
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<string>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: string): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_textarea implements interface_input<string> {
|
|
/**
|
|
*/
|
|
private dom_textarea;
|
|
/**
|
|
*/
|
|
constructor();
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<string>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: string): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_date implements interface_input<(null | type_date)> {
|
|
/**
|
|
*/
|
|
private required;
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
constructor(options?: {
|
|
required?: boolean;
|
|
});
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<(null | type_date)>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: (null | type_date)): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
* @todo abstract
|
|
*/
|
|
class class_input_number implements interface_input<number> {
|
|
/**
|
|
*/
|
|
private read_only;
|
|
/**
|
|
*/
|
|
private step;
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
constructor(options?: {
|
|
read_only?: boolean;
|
|
step?: (null | float);
|
|
});
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<number>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: number): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_checkbox implements interface_input<boolean> {
|
|
/**
|
|
*/
|
|
private read_only;
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
private hooks_change;
|
|
/**
|
|
*/
|
|
constructor(options?: {
|
|
read_only?: boolean;
|
|
hooks_change?: Array<((value: boolean) => void)>;
|
|
});
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<boolean>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: boolean): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_selection implements interface_input<string> {
|
|
/**
|
|
*/
|
|
private options;
|
|
/**
|
|
*/
|
|
private dom_select;
|
|
/**
|
|
*/
|
|
constructor(options: Array<{
|
|
value: string;
|
|
label: string;
|
|
}>);
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<string>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: string): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_enumeration implements interface_input<string> {
|
|
/**
|
|
*/
|
|
private options;
|
|
/**
|
|
*/
|
|
private dom_inputs;
|
|
/**
|
|
*/
|
|
constructor(options: Array<{
|
|
value: string;
|
|
label: string;
|
|
}>);
|
|
/**
|
|
* [implementation]
|
|
* @todo unique name
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<string>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: string): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
*/
|
|
type type_translations = {
|
|
add?: string;
|
|
remove?: string;
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
export class class_input_list<type_element> implements interface_input<Array<type_element>> {
|
|
/**
|
|
*/
|
|
private element_input_factory;
|
|
/**
|
|
*/
|
|
private elements_container_dom;
|
|
/**
|
|
*/
|
|
private elements;
|
|
/**
|
|
*/
|
|
private translations;
|
|
/**
|
|
*/
|
|
constructor(element_input_factory: (() => interface_input<type_element>), options?: {
|
|
translations?: type_translations;
|
|
});
|
|
/**
|
|
*/
|
|
private clear;
|
|
/**
|
|
*/
|
|
private add;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<Array<type_element>>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: Array<type_element>): Promise<void>;
|
|
}
|
|
export {};
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_password implements interface_input<string> {
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
constructor();
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<string>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: string): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_switch implements interface_input<boolean> {
|
|
/**
|
|
*/
|
|
private dom_element;
|
|
/**
|
|
*/
|
|
private value;
|
|
/**
|
|
*/
|
|
constructor();
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<boolean>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: boolean): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_time implements interface_input<(null | type_time)> {
|
|
/**
|
|
*/
|
|
private dom_input;
|
|
/**
|
|
*/
|
|
constructor();
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<(null | type_time)>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: (null | type_time)): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_input {
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
class class_input_group<type_record> implements interface_input<type_record> {
|
|
/**
|
|
*/
|
|
private fields;
|
|
/**
|
|
*/
|
|
constructor(fields_raw: Array<{
|
|
name: string;
|
|
input: interface_input<any>;
|
|
label?: (null | string);
|
|
help?: (null | string);
|
|
}>);
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
read(): Promise<type_record>;
|
|
/**
|
|
* [implementation]
|
|
*/
|
|
write(value: type_record): Promise<void>;
|
|
}
|
|
}
|
|
declare namespace lib_plankton.zoo_form {
|
|
/**
|
|
*/
|
|
type type_field = {
|
|
name: string;
|
|
type: string;
|
|
label: (null | string);
|
|
};
|
|
/**
|
|
*/
|
|
export type type_form<type_value> = {
|
|
method: string;
|
|
fields: Array<type_field>;
|
|
encode: ((value: type_value) => Record<string, string>);
|
|
decode: ((raw: Record<string, string>) => type_value);
|
|
class_prefix: string;
|
|
root_element: (null | Element);
|
|
};
|
|
/**
|
|
*/
|
|
export function make<type_value>(method: string, fields: Array<{
|
|
name: string;
|
|
type: string;
|
|
label?: (null | string);
|
|
}>, encode: ((value: type_value) => Record<string, string>), decode: ((raw: Record<string, string>) => type_value), options?: {
|
|
class_prefix?: string;
|
|
}): type_form<type_value>;
|
|
/**
|
|
*/
|
|
export function make_simple(method: string, fields: Array<{
|
|
name: string;
|
|
type: string;
|
|
label?: (null | string);
|
|
}>, options?: {
|
|
class_prefix?: string;
|
|
}): type_form<Record<string, any>>;
|
|
/**
|
|
*/
|
|
export function clear<type_value>(subject: type_form<type_value>): void;
|
|
/**
|
|
*/
|
|
export function write<type_value>(subject: type_form<type_value>, value: type_value): void;
|
|
/**
|
|
*/
|
|
export function read<type_value>(subject: type_form<type_value>): type_value;
|
|
/**
|
|
*/
|
|
export function render<type_value>(subject: type_form<type_value>, target: Element): Promise<void>;
|
|
export {};
|
|
}
|
|
declare namespace lib_plankton.zoo_form {
|
|
/**
|
|
*/
|
|
type type_action<type_value, type_representation> = {
|
|
label: string;
|
|
target?: string;
|
|
procedure?: ((get_value?: (() => Promise<type_value>), get_representation?: (() => Promise<type_representation>)) => void);
|
|
};
|
|
/**
|
|
* @author fenris
|
|
*/
|
|
export class class_form<type_value, type_representation> {
|
|
/**
|
|
*/
|
|
private encode;
|
|
/**
|
|
*/
|
|
private decode;
|
|
/**
|
|
*/
|
|
private actions;
|
|
/**
|
|
*/
|
|
private input;
|
|
/**
|
|
*/
|
|
constructor(encode: ((value: type_value) => type_representation), decode: ((representation: type_representation) => type_value), input: lib_plankton.zoo_input.interface_input<type_representation>, actions: Array<type_action<type_value, type_representation>>);
|
|
/**
|
|
*/
|
|
setup(parent: HTMLElement): Promise<void>;
|
|
/**
|
|
*/
|
|
input_read_raw(): Promise<type_representation>;
|
|
/**
|
|
*/
|
|
input_read(): Promise<type_value>;
|
|
/**
|
|
*/
|
|
input_write(value: type_value): Promise<void>;
|
|
}
|
|
export {};
|
|
}
|