espe/frontend-zackeneule
0
0
Fork 0
Code Issues Pull requests 1 Projects Releases Packages Wiki Activity Actions
frontend-zackeneule/lib/plankton/plankton.js
Christian Fraß 76a2d7dff4 [task-193] [int]
2025-04-12 10:19:59 +00:00

8869 lines
329 KiB
JavaScript
Raw Blame History

/*
This file is part of »bacterio-plankton:base«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
*/
// }
/*
This file is part of »bacterio-plankton:base«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
*/
;
/*
declare class console {
static log(...args : any[]) : void;
static info(...args : any[]) : void;
static warn(...args : any[]) : void;
static error(...args : any[]) : void;
};
*/
var lib_plankton;
(function (lib_plankton) {
var base;
(function (base) {
/**
* @author fenris
*/
function environment() {
return "web";
}
base.environment = environment;
})(base = lib_plankton.base || (lib_plankton.base = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:base«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @author fenris
*/
/*export*/ function pseudopointer_null() {
return {
"value": null
};
}
/**
* @author fenris
*/
/*export*/ function pseudopointer_make(value) {
return {
"value": value
};
}
/**
* @author fenris
*/
/*export*/ function pseudopointer_isset(pseudopointer) {
return (pseudopointer.value != null);
}
/**
* @author fenris
*/
/*export*/ function pseudopointer_read(pseudopointer) {
if (pseudopointer.value != null) {
return pseudopointer.value;
}
else {
let message = `nullpointer dereferencation`;
throw (new Error(message));
}
}
/**
* @author fenris
*/
/*export*/ function pseudopointer_write(pseudopointer, value) {
pseudopointer.value = value;
}
/*
This file is part of »bacterio-plankton:base«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @author fenris
*/
var instance_verbosity = 0;
/**
* @author fenris
*/
function instance_collate(value1, value2) {
if (typeof (value1) === "object") {
if (value1 == null) {
return (value2 == null);
}
else {
if ("_collate" in value1) {
return value1["_collate"](value2);
}
else {
throw (new Error("[collate]" + " " + "object has no such method"));
}
}
}
else {
if (instance_verbosity >= 1) {
// lib_plankton.log.warn("[collate]" + " " + "primitive value; using default implementation");
}
return (value1 === value2);
}
}
/**
* @author fenris
*/
function instance_compare(value1, value2) {
if (typeof (value1) === "object") {
if ("_compare" in value1) {
return value1["_compare"](value2);
}
else {
throw (new Error("[compare]" + " " + "object has no such method"));
}
}
else {
if (instance_verbosity >= 1) {
// lib_plankton.log.warn("[compare]" + " " + "primitive value; using default implementation");
}
return (value1 <= value2);
}
}
/**
* @author fenris
*/
function instance_clone(value) {
if (typeof (value) === "object") {
if ("_clone" in value) {
return value["_clone"]();
}
else {
throw (new Error("[clone]" + " " + "object has no such method"));
}
}
else {
if (instance_verbosity >= 1) {
// lib_plankton.log.warn("[clone]" + " " + "primitive value; using default implementation");
}
return value;
}
}
/**
* @desc the ability to generate a string out of the element, which identifies it to a high degree
* @author fenris
*/
function instance_hash(value) {
if (typeof (value) === "object") {
if ("_hash" in value) {
return value["_hash"]();
}
else {
throw (new Error("[hash]" + " " + "object has no such method"));
}
}
else {
if (instance_verbosity >= 1) {
// lib_plankton.log.warn("[hash]" + " " + "primitive value; using default implementation");
}
return String(value);
}
}
/**
* @desc the ability to map the element to a textual representation (most likely not injective)
* @author fenris
*/
function instance_show(value) {
if (typeof (value) === "object") {
if (value == null) {
return "NULL";
}
else {
if ("_show" in value) {
return value["_show"]();
}
else {
// throw (new Error("[show]" + " " + "object has no such method"));
return JSON.stringify(value);
}
}
}
else {
if (instance_verbosity >= 1) {
// lib_plankton.log.warn("[show]" + " " + "primitive value; using default implementation");
}
return String(value);
}
}
/*
This file is part of »bacterio-plankton:base«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @author frac
*/
class class_observer {
/**
* @author frac
*/
constructor() {
this.counter = 0;
this.actions = {};
this.buffer = [];
}
/**
* @author frac
*/
empty() {
return (Object.keys(this.actions).length == 0);
}
/**
* @author frac
*/
flush() {
this.actions = {};
}
/**
* @author frac
*/
set(id, action) {
this.actions[id] = action;
}
/**
* @author frac
*/
del(id) {
delete this.actions[id];
}
/**
* @author frac
*/
add(action) {
this.set((this.counter++).toString(), action);
}
/**
* @author frac
*/
notify(information = {}, delayed = false) {
if (delayed) {
this.buffer.push(information);
}
else {
Object.keys(this.actions).forEach(id => this.actions[id](information));
}
}
/**
* @author frac
*/
rollout() {
this.buffer.forEach(information => this.notify(information, false));
this.buffer = [];
}
}
/**
* @author frac
*/
/*
export interface interface_readable<type_value> {
|**
* @author frac
*|
read() : type_executor<type_value, Error>;
}
*/
/**
* @author frac
*/
/*
export interface interface_writeable<type_value> {
|**
* @author frac
*|
write(value : type_value) : type_executor<void, Error>;
}
*/
/*
This file is part of »bacterio-plankton:base«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* @author frac
*/
class class_error extends Error {
/**
* @author frac
*/
constructor(message, suberrors = []) {
super(message);
this.suberrors = suberrors;
this.mess = message;
}
/**
* @override
* @author frac
*/
toString() {
return ( /*super.toString()*/this.mess + " " + ("[" + this.suberrors.map(x => x.toString()).join(",") + "]"));
}
}
/*
This file is part of »bacterio-plankton:base«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var base;
(function (base) {
/**
* returns the current UNIX timestamp
*
* @author fenris
*/
function get_current_timestamp(rounded = false) {
const x = (Date.now() / 1000);
return (rounded ? Math.round(x) : x);
;
}
base.get_current_timestamp = get_current_timestamp;
/**
*/
function object_merge(core, mantle) {
return Object.assign(core, mantle);
}
base.object_merge = object_merge;
/**
*/
function buffer_show(buffer, { "block_size": option_block_size = 20, "break_char": option_break_char = "\n", } = {}) {
let output = "";
let count = 0;
// @ts-ignore
for (const entry of buffer) {
count = ((count + 1) % option_block_size);
output += ((typeof (entry) === "string")
?
entry.charCodeAt(0)
:
entry).toString(16).toUpperCase().padStart(2, "0");
output += ((count === 0) ? option_break_char : " ");
}
return output;
}
base.buffer_show = buffer_show;
})(base = lib_plankton.base || (lib_plankton.base = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:pod«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:pod« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:pod« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:pod«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var pod;
(function (pod_1) {
/**
* @author fenris
*/
function make_empty() {
return {
"kind": "empty"
};
}
pod_1.make_empty = make_empty;
/**
* @author fenris
*/
function make_filled(value) {
return {
"kind": "filled",
"value": value
};
}
pod_1.make_filled = make_filled;
/**
* whether the pod is filled
*
* @author fenris
*/
function is_filled(pod) {
return (pod.kind === "filled");
}
pod_1.is_filled = is_filled;
/**
* return the value, stored in the pod-wrapper
*
* @author fenris
*/
function cull(pod) {
if (!is_filled(pod)) {
throw (new Error("cull from empty"));
}
else {
return pod.value;
}
}
pod_1.cull = cull;
/**
* to pass on a empty-pod or to use a filled-pod
*
* @author fenris
*/
function propagate(pod, function_) {
if (!is_filled(pod)) {
return make_empty();
}
else {
return make_filled(function_(pod.value));
}
}
pod_1.propagate = propagate;
/**
* @author fenris
*/
function distinguish(pod, function_empty, function_filled) {
return ((!is_filled(pod))
? function_empty()
: function_filled(pod.value));
}
pod_1.distinguish = distinguish;
/**
*/
function show(pod, options = {}) {
options = Object.assign({
"show_value": value => String(value),
}, options);
if (!is_filled(pod)) {
return "<·>";
}
else {
return ("<- " + options.show_value(pod.value) + " ->");
}
}
pod_1.show = show;
})(pod = lib_plankton.pod || (lib_plankton.pod = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:pod«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:pod« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:pod« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:pod«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var pod;
(function (pod) {
/**
*/
class class_pod {
constructor(subject) { this.subject = subject; }
tear() { return this.subject; }
static empty() { return (new class_pod(pod.make_empty())); }
static filled(value) { return (new class_pod(pod.make_filled(value))); }
is_empty() { return (!pod.is_filled(this.subject)); }
is_filled() { return pod.is_filled(this.subject); }
cull() { return pod.cull(this.subject); }
show(show_value = undefined) { return pod.show(this.subject, show_value); }
toString() { return this.show(); }
propagate(function_) { return new class_pod(pod.propagate(this.subject, function_)); }
distinguish(function_empty, function_filled) { return pod.distinguish(this.subject, function_empty, function_filled); }
}
pod.class_pod = class_pod;
})(pod = lib_plankton.pod || (lib_plankton.pod = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:call«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:call« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:call« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* might be completely obsolete
*/
var lib_plankton;
(function (lib_plankton) {
var call;
(function (call) {
/**
* @author fenris
*/
function promise_reject(reason) {
return Promise.reject(reason);
}
call.promise_reject = promise_reject;
/**
* @author fenris
*/
function promise_resolve(result) {
return Promise.resolve(result);
}
call.promise_resolve = promise_resolve;
/**
* @author fenris
*/
function promise_make(executor) {
return (new Promise(executor));
}
call.promise_make = promise_make;
/**
* @author fenris
*/
function promise_then_close(promise, resolver, rejector) {
promise.then(resolver, rejector);
}
call.promise_then_close = promise_then_close;
/**
* @author fenris
*/
function promise_then_append(promise, resolver, rejector = null) {
if (rejector == null) {
rejector = (reason) => promise_reject(reason);
}
return (promise.then(resolver, rejector));
}
call.promise_then_append = promise_then_append;
/**
* @author fenris
*/
function promise_all(promises) {
return Promise.all(promises);
}
call.promise_all = promise_all;
/**
* @author fenris
*/
function promise_chain(promises, start = undefined) {
return (promises.reduce((chain, promise) => promise_then_append(chain, promise), promise_resolve(start)));
}
call.promise_chain = promise_chain;
/**
* @author fenris
*/
function promise_condense(promises) {
return (promise_chain(promises.map(promise => result => promise_then_append(promise(), element => promise_resolve(result.concat([element])))), []));
}
call.promise_condense = promise_condense;
/**
* @author fenris
*/
function promise_group(promises, options = {
"serial": false,
}) {
const decorate = function (promise, name) {
return (() => promise_then_append(promise(), value => promise_resolve({ "key": name, "value": value })));
};
if (options.serial) {
return (promise_then_append(promise_condense(Object.keys(promises)
.map(name => decorate(promises[name], name))), list => promise_resolve(Object.fromEntries(list.map(({ "key": key, "value": value }) => ([key, value]))))));
}
else {
return (promise_then_append(promise_all(Object.keys(promises)
.map(name => decorate(promises[name], name))
.map(promise => promise())), list => promise_resolve(Object.fromEntries(list.map(({ "key": key, "value": value }) => ([key, value]))))));
}
}
call.promise_group = promise_group;
/**
* @author fenris
*/
function promise_wrap(promise, transformator_result, transformator_reason = lib_plankton.call.id) {
return (promise_make((resolve, reject) => {
promise_then_close(promise, result => resolve(transformator_result(result)), reason => reject(transformator_reason(reason)));
}));
}
call.promise_wrap = promise_wrap;
/**
* @author fenris
*/
/*
export function promise_show<type_result, type_reason>(label : string) : (result : type_result)=>type_promise<type_result, type_reason> {
return (
result => promise_make<type_result, type_reason>(
(resolve, reject) => {
// lib_plankton.log.info(label + ": " + instance_show(result));
process.stdout.write(label + ": " + instance_show(result));
resolve(result);
}
)
);
}
*/
/**
* @author fenris
*/
/*
export function promise_log<type_result, type_reason>(result : type_result) : (result : type_result)=>type_promise<type_result, type_reason> {
return promise_show<type_result, type_reason>("log");
}
*/
/**
* @author fenris
*/
function promise_attach(state, promise, name) {
return (promise_wrap(promise, result => {
state[name] = result;
return state;
}));
}
call.promise_attach = promise_attach;
/**
* @author fenris
*/
function promise_delay(promise, delay) {
return promise_make((resolve, reject) => {
call.timeout(() => {
promise_then_close(promise, resolve, reject);
return null;
}, delay);
});
}
call.promise_delay = promise_delay;
})(call = lib_plankton.call || (lib_plankton.call = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:call«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:call« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:call« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* initializer might be obsolete, since promises are reusable after having been resolved or rejected
*/
var lib_plankton;
(function (lib_plankton) {
var call;
(function (call) {
/**
* @author fenris
*/
let enum_initializer_state;
(function (enum_initializer_state) {
enum_initializer_state[enum_initializer_state["initial"] = 0] = "initial";
enum_initializer_state[enum_initializer_state["waiting"] = 1] = "waiting";
enum_initializer_state[enum_initializer_state["successful"] = 2] = "successful";
enum_initializer_state[enum_initializer_state["failed"] = 3] = "failed";
})(enum_initializer_state = call.enum_initializer_state || (call.enum_initializer_state = {}));
/**
* @author fenris
*/
function initializer_make(fetcher) {
let subject = {
"fetcher": fetcher,
"state": enum_initializer_state.initial,
"queue": [],
"result": undefined,
"reason": undefined,
};
return subject;
}
call.initializer_make = initializer_make;
/**
* @author fenris
*/
function initializer_actuate(subject) {
switch (subject.state) {
case enum_initializer_state.successful: {
subject.queue.forEach(entry => entry.resolve(subject.result));
break;
}
case enum_initializer_state.failed: {
subject.queue.forEach(entry => entry.reject(subject.reason));
break;
}
default: {
throw (new Error(`unhandled state ${subject.state}`));
break;
}
}
}
/**
* @author fenris
*/
function initializer_reset(subject) {
subject.state = enum_initializer_state.initial;
subject.queue = [];
}
call.initializer_reset = initializer_reset;
/**
* @author fenris
*/
function initializer_state(subject) {
return subject.state;
}
call.initializer_state = initializer_state;
/**
* @author fenris
*/
function initializer_get(subject) {
switch (subject.state) {
case enum_initializer_state.initial: {
subject.state = enum_initializer_state.waiting;
return (call.promise_make((resolve, reject) => {
subject.queue.push({ "resolve": resolve, "reject": reject });
subject.fetcher().then(result => {
subject.state = enum_initializer_state.successful;
subject.result = result;
initializer_actuate(subject);
}, reason => {
subject.state = enum_initializer_state.failed;
subject.reason = reason;
initializer_actuate(subject);
});
}));
break;
}
case enum_initializer_state.waiting: {
return (call.promise_make((resolve, reject) => {
subject.queue.push({ "resolve": resolve, "reject": reject });
}));
break;
}
case enum_initializer_state.successful: {
return (call.promise_resolve(subject.result));
break;
}
case enum_initializer_state.failed: {
return (call.promise_reject(subject.reason));
break;
}
default: {
throw (new Error(`unhandled state ${subject.state}`));
break;
}
}
}
call.initializer_get = initializer_get;
/**
* @author fenris
*/
function initializer_get_sync(subject) {
switch (subject.state) {
case enum_initializer_state.successful: {
return subject.result;
break;
}
case enum_initializer_state.failed: {
throw subject.reason;
break;
}
default: {
throw (new Error(`unhandled state ${subject.state}`));
break;
}
}
}
/**
* @author fenris
*/
function initializer_set_sync(subject, result) {
switch (subject.state) {
case enum_initializer_state.successful: {
subject.result = result;
break;
}
case enum_initializer_state.failed: {
subject.state = enum_initializer_state.successful;
subject.result = result;
break;
}
default: {
throw (new Error(`unhandled state ${subject.state}`));
break;
}
}
}
})(call = lib_plankton.call || (lib_plankton.call = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:call«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:call« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:call« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var call;
(function (call) {
/*
The core idea of this library is to provide means for asynchronous program flow. The old-school way to do is,
is to use callbacks. While this approach is simple and easy to understand, it has some disadvantages. As an
attempt to relief and improve this, the promise-system was introduced. In principle it solves most of the
problems found in the callback-approach; however it has some downsides as well:
- Convolution of multiple principles
Promises unite the ideas of asynchronous program flow and error handling.
- Instant execution
Creating a promise results in the instant execution of the given executor prodecure. While this might be
convenient in some cases, it can be quite disturbing and counter-intuitive in others.
- Broken typing
The Promise system doesn't distinguish between an appending "then" (i.e. passing a function, which returns a
new promise) and a closing "then" (i.e. passing a function, which has no return value). On top of that it
allows returning simple values in an appending "then", which results in an implicit call of the executors
"resolve"-function. The price for these "pragmatic" features is that the whole system can't be typed well.
And even though JavaScript is not a strictly typed language, it was a quite questionable decision to design
the promise system in a way, which breaks typing from the start.
The deferral-system forseeks to solve these issues while retaining the advantages of the promise-system.
*/
/**
* @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(deferral, input, procedure) {
deferral.representation(input).then(value => {
procedure(value);
}, reason => {
throw reason;
});
}
call.deferral_use = deferral_use;
/**
* @author fenris
* @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject")
*/
function deferral_make(handler) {
return ({
"representation": ((input) => (new Promise((resolve, reject) => {
handler(input, resolve);
})))
});
}
call.deferral_make = deferral_make;
/**
* @author fenris
* @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject")
*/
function deferral_wrap(function_) {
return (deferral_make((input, convey) => convey(function_(input))));
}
call.deferral_wrap = deferral_wrap;
/**
* @author fenris
*/
function deferral_id() {
return (deferral_make((input, convey) => convey(input)));
}
call.deferral_id = deferral_id;
/**
* @author fenris
*/
function deferral_const(value) {
return (deferral_make((input, convey) => convey(value)));
}
call.deferral_const = deferral_const;
/**
* @author fenris
*/
function deferral_delay(output, delay) {
return (deferral_make((input, convey) => {
setTimeout(() => convey(output), delay);
}));
}
call.deferral_delay = deferral_delay;
/**
* @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(first, second) {
return {
"representation": ((input) => first.representation(input).then((between) => second.representation(between)))
};
}
call.deferral_compose_serial = deferral_compose_serial;
/**
* @author fenris
*/
function deferral_compose_parallel({ "left": deferral_left, "right": deferral_right, }) {
return (deferral_make((input, convey) => {
let object = {
"left": lib_plankton.pod.make_empty(),
"right": lib_plankton.pod.make_empty(),
};
let finish = function () {
if (lib_plankton.pod.is_filled(object.left)
&&
lib_plankton.pod.is_filled(object.right)) {
let result = {
"left": lib_plankton.pod.cull(object.left),
"right": lib_plankton.pod.cull(object.right),
};
convey(result);
}
else {
// do nothing
}
};
deferral_use(deferral_left, input, output_left => {
object.left = lib_plankton.pod.make_filled(output_left);
finish();
});
deferral_use(deferral_right, input, output_right => {
object.right = lib_plankton.pod.make_filled(output_right);
finish();
});
}));
}
call.deferral_compose_parallel = deferral_compose_parallel;
/**
* @author fenris
* @desc repeatedly applied serial composition
*/
function deferral_chain(members) {
return (members.reduce(
// (result, current) => deferral_compose_serial<type_value, type_value, type_value>(result, current),
deferral_compose_serial, deferral_id()));
}
call.deferral_chain = deferral_chain;
/**
* @author fenris
*/
/*
export function deferral_bunch<type_input, type_output>(
members : {[name : string] : type_deferral<type_input, type_output>}
) : type_deferral<type_input, {[name : string] : type_output}> {
}
*/
})(call = lib_plankton.call || (lib_plankton.call = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:call«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:call« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:call« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var call;
(function (call) {
/**
* @author fenris
*/
class class_deferral {
/**
* @author fenris
*/
constructor(subject) {
this.subject = subject;
}
/**
* @author fenris
*/
static _cram(subject) {
return (new class_deferral(subject));
}
/**
* @author fenris
*/
static _tear(instance) {
return instance.subject;
}
/**
* @author fenris
*/
static make(handler) {
return (class_deferral._cram(call.deferral_make(handler)));
}
/**
* @author fenris
*/
use(input, procedure) {
return (call.deferral_use(class_deferral._tear(this), input, procedure));
}
/**
* @author fenris
*/
compose_serial(second) {
return (class_deferral._cram(call.deferral_compose_serial(class_deferral._tear(this), class_deferral._tear(second))));
}
/**
* @author fenris
*/
static chain(members) {
return (class_deferral._cram(call.deferral_chain(members.map(member => class_deferral._tear(member)))));
}
/**
* @author fenris
*/
static wrap(function_) {
return (class_deferral._cram(call.deferral_wrap(function_)));
}
/**
* @author fenris
*/
static const_(value) {
return (class_deferral._cram(call.deferral_const(value)));
}
/**
* @author fenris
*/
static delay(output, delay) {
return (class_deferral._cram(call.deferral_delay(output, delay)));
}
}
call.class_deferral = class_deferral;
})(call = lib_plankton.call || (lib_plankton.call = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:call«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:call« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:call« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:call«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var call;
(function (call) {
/**
* converts the "arguments"-map into an array
*
* @param {Object} args
* @author fenris
*/
function args2list(args) {
return Object.keys(args).map(key => args[key]);
}
call.args2list = args2list;
/**
* just the empty function; useful for some callbacks etc.
*
* @author fenris
*/
function nothing() {
}
call.nothing = nothing;
/**
* just the identity; useful for some callbacks etc.; defined as function instead of const for using type parameters
*
* @author fenris
*/
function id(x) {
return x;
}
call.id = id;
/**
* just the identity; useful for some callbacks etc.
*
* @author fenris
*/
function const_(x) {
return (y => x);
}
call.const_ = const_;
/**
* 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(function_f, function_g) {
return (function (x) {
// return function_g(function_f(x));
return function_g(function_f.apply(function_f, args2list(arguments)));
});
}
call.compose = compose;
/**
* @author fenris
*/
function curryfy_real(f, n) {
switch (n) {
case 0: {
throw (new Error("[curryfy] impossible"));
// break;
}
case 1: {
return f;
// break;
}
default: {
return (function (x) {
return (curryfy_real(function () { return f.apply(f, [x].concat(args2list(arguments))); }, n - 1));
});
// break;
}
}
}
/**
* 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) {
return curryfy_real(f, f.length);
}
call.curryfy = curryfy;
/**
* @author fenris
*/
function convey(value, functions) {
let result = value;
functions.forEach(function_ => {
result = function_(result);
});
return result;
}
call.convey = convey;
/**
*/
class class_value_wrapper {
/**
*/
constructor(value) {
this.value = value;
}
/**
*/
convey(function_) {
return (new class_value_wrapper(function_(this.value)));
}
/**
*/
cull() {
return this.value;
}
}
/**
*/
function wrap(value) {
return (new class_value_wrapper(value));
}
call.wrap = wrap;
/**
* @author fenris
*/
function timeout(procedure, delay_in_seconds) {
return (
/*window.*/ setTimeout(procedure, Math.floor(delay_in_seconds * 1000)));
}
call.timeout = timeout;
/**
* Promise version of "setTimeout"
*
* @author fenris
*/
function defer(seconds, action) {
return (new Promise((resolve, reject) => {
setTimeout(() => resolve(action()), Math.floor(seconds * 1000));
}));
}
call.defer = defer;
/**
* a definition for a value being "defined"
*
* @author neuc
*/
function is_def(obj, options = {}) {
options = Object.assign({
"null_is_valid": false,
}, options);
return (!((typeof (obj) === "undefined")
||
(!options.null_is_valid && (obj === null))));
}
call.is_def = is_def;
/**
* 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, default_value, options = {}) {
options = Object.assign({
"type": null,
"null_is_valid": false,
}, options);
if (is_def(value, { "null_is_valid": options.null_is_valid })
&&
(is_def(options.type)
? ((typeof (value) === options.type)
||
((value === null)
&&
options.null_is_valid))
: true)) {
return value;
}
else {
return default_value;
}
}
call.def_val = def_val;
;
/**
* 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(name) {
return (object => object[name]);
}
call.attribute = 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(name) {
return (function (object) { return object[name].apply(object, args2list(arguments).slice(1)); });
}
call.method = method;
/**
* @author fenris
*/
function distinguish(coproduct, handlers, options = {}) {
options = Object.assign({
"fallback": null,
}, options);
if (coproduct.kind in handlers) {
const handler = handlers[coproduct.kind];
return handler(coproduct.data);
}
else {
const message = ("unhandled kind '" + coproduct.kind + "'");
if (options.fallback !== null) {
console.warn(message);
return options.fallback(coproduct);
}
else {
throw (new Error(message));
}
}
}
call.distinguish = distinguish;
/**
*/
function try_catch_wrap(get_value) {
try {
return {
"value": get_value(),
"error": null,
};
}
catch (error) {
return {
"value": null,
"error": error,
};
}
}
call.try_catch_wrap = try_catch_wrap;
/**
*/
function try_catch_wrap_async(get_value) {
return (get_value()
.then((value) => Promise.resolve({
"value": value,
"error": null,
}))
.catch((reason) => Promise.resolve({
"value": null,
"error": reason,
})));
}
call.try_catch_wrap_async = try_catch_wrap_async;
})(call = lib_plankton.call || (lib_plankton.call = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:file«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:file« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:file« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:file«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var file;
(function (file) {
/**
* @author fenris
*/
function read(path) {
return (fetch("/" + path)
.then(function (result) { return result.text(); }));
}
file.read = read;
/**
* @author fenris
*/
function write(path, content) {
return Promise.reject(new Error("not implemented / not possible"));
}
file.write = write;
/**
* @author fenris
*/
function blob_read_text(blob) {
return (lib_plankton.call.promise_make(function (resolve, reject) {
var reader = (new FileReader());
reader.addEventListener("load", function (event) {
resolve((reader.result));
});
reader.addEventListener("error", function (event) {
reject(new Error("reading file failed"));
});
reader.addEventListener("abort", function (event) {
reject(new Error("reading file aborted"));
});
reader.readAsText(blob);
}));
}
file.blob_read_text = blob_read_text;
/**
* @author fenris
*/
function blob_read_arraybuffer(blob) {
return (lib_plankton.call.promise_make(function (resolve, reject) {
var reader = (new FileReader());
reader.addEventListener("load", function (event) {
resolve((reader.result));
});
reader.addEventListener("error", function (event) {
reject(new Error("reading file failed"));
});
reader.addEventListener("abort", function (event) {
reject(new Error("reading file aborted"));
});
reader.readAsArrayBuffer(blob);
}));
}
file.blob_read_arraybuffer = blob_read_arraybuffer;
/**
* @author fenris
*/
function blob_read_dataurl(blob) {
return (lib_plankton.call.promise_make(function (resolve, reject) {
var reader = new FileReader();
reader.addEventListener("load", function (event) {
resolve((reader.result));
});
reader.addEventListener("error", function (event) {
reject(new Error("reading file failed"));
});
reader.addEventListener("abort", function (event) {
reject(new Error("reading file aborted"));
});
reader.readAsDataURL(blob);
}));
}
file.blob_read_dataurl = blob_read_dataurl;
/**
* @author fenris
*/
function blob_write_text(text) {
var blob = (new Blob([text], { "type": "text/plain" }));
return lib_plankton.call.promise_resolve(blob);
}
file.blob_write_text = blob_write_text;
})(file = lib_plankton.file || (lib_plankton.file = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author fenris
*/
function inverse_encode(decode, to) {
return decode(to);
}
code.inverse_encode = inverse_encode;
/**
* @author fenris
*/
function inverse_decode(encode, from) {
return encode(from);
}
code.inverse_decode = inverse_decode;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author fenris
*/
var class_code_inverse = /** @class */ (function () {
/**
* @author fenris
*/
function class_code_inverse(subject) {
this.subject = subject;
}
/**
* @implementation
* @author fenris
*/
class_code_inverse.prototype.encode = function (to) {
var _this = this;
return code.inverse_encode(function (x) { return _this.subject.decode(x); }, to);
};
/**
* @implementation
* @author fenris
*/
class_code_inverse.prototype.decode = function (from) {
var _this = this;
return code.inverse_decode(function (x) { return _this.subject.encode(x); }, from);
};
return class_code_inverse;
}());
code.class_code_inverse = class_code_inverse;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author fenris
*/
function pair_encode(encode_first, encode_second, from) {
var between = encode_first(from);
var to = encode_second(between);
return to;
}
code.pair_encode = pair_encode;
/**
* @author fenris
*/
function pair_decode(decode_first, decode_second, to) {
var between = decode_second(to);
var from = decode_first(between);
return from;
}
code.pair_decode = pair_decode;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author fenris
*/
var class_code_pair = /** @class */ (function () {
/**
* @author fenris
*/
function class_code_pair(first, second) {
this.first = first;
this.second = second;
}
/**
* @implementation
* @author fenris
*/
class_code_pair.prototype.encode = function (from) {
var _this = this;
return code.pair_encode(function (x) { return _this.first.encode(x); }, function (x) { return _this.second.encode(x); }, from);
};
/**
* @implementation
* @author fenris
*/
class_code_pair.prototype.decode = function (to) {
var _this = this;
return code.pair_decode(function (x) { return _this.first.decode(x); }, function (x) { return _this.second.decode(x); }, to);
};
return class_code_pair;
}());
code.class_code_pair = class_code_pair;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author fenris
*/
function chain_encode(encode_links, from) {
var value = from;
encode_links
.forEach(function (link) {
value = link(value);
});
return value;
}
code.chain_encode = chain_encode;
/**
* @author fenris
*/
function chain_decode(decode_links, to) {
var value = to;
decode_links
.reverse()
.forEach(function (link) {
value = link(value);
});
return value;
}
code.chain_decode = chain_decode;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author fenris
*/
var class_code_chain = /** @class */ (function () {
/**
* @author fenris
*/
function class_code_chain(links) {
this.links = links;
}
/**
* @implementation
* @author fenris
*/
class_code_chain.prototype.encode = function (from) {
return code.chain_encode(this.links.map(function (link) { return (function (x) { return link.encode(x); }); }), from);
};
/**
* @implementation
* @author fenris
*/
class_code_chain.prototype.decode = function (to) {
return code.chain_decode(this.links.map(function (link) { return (function (x) { return link.decode(x); }); }), to);
};
return class_code_chain;
}());
code.class_code_chain = class_code_chain;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author Christian Fraß <frass@greenscale.de>
*/
function flatten_encode(from, keys) {
if (keys === void 0) { keys = null; }
if (keys === null) {
if (from.length > 0) {
keys = Object.keys(from[0]);
}
else {
throw (new Error("encoding impossible"));
}
}
return {
"keys": keys,
"data": from.map(function (line) { return keys.map(function (name) { return line[name]; }); })
};
}
code.flatten_encode = flatten_encode;
/**
* @author Christian Fraß <frass@greenscale.de>
*/
function flatten_decode(to) {
return (to.data
.map(function (dataset) {
var dataset_ = {};
dataset
.forEach(function (value, index) {
var name = to.keys[index];
dataset_[name] = value;
});
return dataset_;
}));
}
code.flatten_decode = flatten_decode;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:code«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:code« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:code« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:code«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var code;
(function (code) {
/**
* @author fenris
*/
var class_code_flatten = /** @class */ (function () {
/**
* @author fenris
*/
function class_code_flatten() {
}
/**
* @implementation
* @author fenris
*/
class_code_flatten.prototype.encode = function (x) {
return code.flatten_encode(x);
};
/**
* @implementation
* @author fenris
*/
class_code_flatten.prototype.decode = function (x) {
return code.flatten_decode(x);
};
return class_code_flatten;
}());
code.class_code_flatten = class_code_flatten;
})(code = lib_plankton.code || (lib_plankton.code = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:json«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:json« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:json« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var json;
(function (json) {
/**
* @author fenris
*/
function encode(source, options = {}) {
options = Object.assign({
"formatted": false,
}, options);
return JSON.stringify(source, undefined, (options.formatted ? "\t" : undefined));
}
json.encode = encode;
/**
* @author fenris
*/
function decode(target) {
return JSON.parse(target);
}
json.decode = decode;
/**
* @author fenris
*/
function implementation_code() {
return {
"encode": x => encode(x),
"decode": decode,
};
}
json.implementation_code = implementation_code;
})(json = lib_plankton.json || (lib_plankton.json = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:json«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:json« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:json« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:json«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var json;
(function (json) {
/**
* @author fenris
*/
class class_json {
/**
* @author fenris
*/
constructor() {
}
/**
* @implementation
* @author fenris
*/
encode(x) {
return json.encode(x);
}
/**
* @implementation
* @author fenris
*/
decode(x) {
return json.decode(x);
}
}
json.class_json = class_json;
})(json = lib_plankton.json || (lib_plankton.json = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:base64«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base64« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base64« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base64«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var base64;
(function (base64) {
/**
* @author fenris
*/
function encode(x) {
return btoa(x);
}
base64.encode = encode;
/**
* @author fenris
*/
function decode(x) {
return atob(x);
}
base64.decode = decode;
})(base64 = lib_plankton.base64 || (lib_plankton.base64 = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:base64«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:base64« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:base64« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:base64«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var base64;
(function (base64) {
/**
* @author fenris
*/
class class_base64 {
/**
* @author fenris
*/
constructor() {
}
/**
* @implementation
* @author fenris
*/
encode(x) {
return base64.encode(x);
}
/**
* @implementation
* @author fenris
*/
decode(x) {
return base64.decode(x);
}
}
base64.class_base64 = class_base64;
})(base64 = lib_plankton.base64 || (lib_plankton.base64 = {}));
})(lib_plankton || (lib_plankton = {}));
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
/*
This file is part of »bacterio-plankton:email«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:email« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:email«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var email;
(function (email) {
/**
*/
function send(smtp_credentials, sender, receivers, subject, content) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
return [2 /*return*/, Promise.reject(new Error("not implemented"))];
});
});
}
email.send = send;
})(email = lib_plankton.email || (lib_plankton.email = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
/**
*/
var enum_level;
(function (enum_level) {
enum_level[enum_level["debug"] = 0] = "debug";
enum_level[enum_level["info"] = 1] = "info";
enum_level[enum_level["notice"] = 2] = "notice";
enum_level[enum_level["warning"] = 3] = "warning";
enum_level[enum_level["error"] = 4] = "error";
})(enum_level = log.enum_level || (log.enum_level = {}));
;
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
/**
*/
function level_order(level1, level2) {
return (level1 <= level2);
}
log.level_order = level_order;
/**
*/
function level_show(level, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["abbreviated"], option_abbreviated = _c === void 0 ? false : _c;
if (option_abbreviated) {
switch (level) {
case log.enum_level.debug: return "DBG";
case log.enum_level.info: return "INF";
case log.enum_level.notice: return "NTC";
case log.enum_level.warning: return "WRN";
case log.enum_level.error: return "ERR";
default: return "(unknown)";
}
}
else {
switch (level) {
case log.enum_level.debug: return "debug";
case log.enum_level.info: return "info";
case log.enum_level.notice: return "notice";
case log.enum_level.warning: return "warning";
case log.enum_level.error: return "error";
default: return "(unknown)";
}
}
}
log.level_show = level_show;
/**
*/
function level_decode(level_string) {
return {
"debug": log.enum_level.debug,
"info": log.enum_level.info,
"notice": log.enum_level.notice,
"warning": log.enum_level.warning,
"error": log.enum_level.error
}[level_string];
}
log.level_decode = level_decode;
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
/**
* @todo use label
*/
function get_logger_logic(logger_data) {
return logger_data.map(function (channel_description) { return lib_plankton.log.get_channel_logic(channel_description); });
}
log.get_logger_logic = get_logger_logic;
/**
*/
function format_entry(format_definition, entry) {
switch (format_definition.kind) {
case "jsonl": {
var now = Date.now();
var timestamp = (now / 1000);
var datetime = (new Date(now)).toISOString();
return (JSON.stringify({
"datetime_timestamp": Math.round(timestamp),
"datetime_string": datetime /*.slice(0, 19)*/,
"level_numeric": entry.level,
"level_name": log.level_show(entry.level, { "abbreviated": false }),
"tags": entry.tags,
"incident": entry.incident,
"details": entry.details
}, undefined, (format_definition.data.structured
?
"\t"
:
undefined)));
break;
}
case "human_readable": {
var parts = [];
parts.push(("<" + (new Date(Date.now())).toISOString() /*.slice(0, 19)*/ + ">"));
parts.push(("[" + log.level_show(entry.level, { "abbreviated": true }) + "]"));
for (var _i = 0, _a = entry.tags; _i < _a.length; _i++) {
var tag = _a[_i];
parts.push(("{" + tag + "}"));
}
parts.push(entry.incident);
(entry.details !== null) && parts.push((": " + JSON.stringify(entry.details, undefined, undefined)));
return (parts.join(" "));
break;
}
default: {
throw (new Error("unhandled format kind: " + format_definition["kind"]));
break;
}
}
}
log.format_entry = format_entry;
/**
*/
function parse_format_definition(format_definition_raw) {
return lib_plankton.call.distinguish((format_definition_raw !== null && format_definition_raw !== void 0 ? format_definition_raw : {
"kind": "human_readable",
"data": {}
}), {
"jsonl": function (_a) {
var structured = _a["structured"];
return ({
"kind": "jsonl",
"data": {
"structured": (structured !== null && structured !== void 0 ? structured : false)
}
});
},
"human_readable": function (data_) { return ({
"kind": "human_readable",
"data": {}
}); }
});
}
log.parse_format_definition = parse_format_definition;
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
var channel;
(function (channel) {
var filtered;
(function (filtered) {
/**
*/
function predicate_incident(substring) {
return (function (entry) { return entry.incident.includes(substring); });
}
filtered.predicate_incident = predicate_incident;
/**
*/
function predicate_level(threshold) {
return (function (entry) { return log.level_order(threshold, entry.level); });
}
filtered.predicate_level = predicate_level;
/**
*/
function predicate_tag(tag) {
return (function (entry) { return entry.tags.includes(tag); });
}
filtered.predicate_tag = predicate_tag;
/**
* combines other predicates in disjunctive normal form
*/
function predicate_complex(definition) {
return (function (entry) { return definition.some(function (clause) { return clause.every(function (literal) { return (literal.item(entry)
===
literal.mode); }); }); });
}
filtered.predicate_complex = predicate_complex;
/**
*/
function send(subject, entry) {
if (!subject.predicate(entry)) {
// do nothing
}
else {
subject.core.send(entry);
}
}
filtered.send = send;
/**
*/
function logic(subject) {
return {
"send": function (entry) { return send(subject, entry); }
};
}
filtered.logic = logic;
})(filtered = channel.filtered || (channel.filtered = {}));
})(channel = log.channel || (log.channel = {}));
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
var channel;
(function (channel) {
var minlevel;
(function (minlevel) {
/**
*/
function to_filter_subject(subject) {
return {
"core": subject.core,
"predicate": lib_plankton.log.channel.filtered.predicate_level(subject.threshold)
};
}
/**
*/
function send(subject, entry) {
lib_plankton.log.channel.filtered.send(to_filter_subject(subject), entry);
}
minlevel.send = send;
/**
*/
function logic(subject) {
return {
"send": function (entry) { return send(subject, entry); }
};
}
minlevel.logic = logic;
})(minlevel = channel.minlevel || (channel.minlevel = {}));
})(channel = log.channel || (log.channel = {}));
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* output for writing log entries to web console
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
var channel;
(function (channel) {
var console_;
(function (console_) {
/**
* @todo tags
*/
function send(subject, entry) {
var _a;
var renderers = (_a = {},
_a[log.enum_level.debug] = {
"renderer": function (i, d) { return console.log(i, d); },
"show_level": true
},
_a[log.enum_level.info] = {
"renderer": function (i, d) { return console.info(i, d); },
"show_level": true
},
_a[log.enum_level.notice] = {
"renderer": function (i, d) { return console.warn(i, d); },
"show_level": true
},
_a[log.enum_level.warning] = {
"renderer": function (i, d) { return console.warn(i, d); },
"show_level": true
},
_a[log.enum_level.error] = {
"renderer": function (i, d) { return console.error(i, d); },
"show_level": true
},
_a);
var setting = renderers[entry.level];
setting.renderer(((setting.show_level
? ("[" + log.level_show(entry.level) + "]" + " ")
: "")
+
("" + entry.incident + "")), entry.details);
}
console_.send = send;
/**
*/
function logic(subject) {
return {
"send": function (entry) { return send(subject, entry); }
};
}
console_.logic = logic;
})(console_ = channel.console_ || (channel.console_ = {}));
})(channel = log.channel || (log.channel = {}));
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
/**
*/
function get_channel_logic(channel_description) {
switch (channel_description.kind) {
default: {
throw (new Error("unhandled log channel kind: " + channel_description.kind));
break;
}
case "filtered": {
return lib_plankton.log.channel.filtered.logic({
"core": get_channel_logic(channel_description.data.core),
"predicate": lib_plankton.log.channel.filtered.predicate_complex(channel_description.data.predicate.map(function (clause_raw) { return clause_raw.map(function (literal_raw) {
var _a;
return ({
"mode": ((_a = literal_raw["mode"]) !== null && _a !== void 0 ? _a : true),
"item": lib_plankton.call.distinguish(literal_raw["item"], {
"incident": function (_a) {
var substring = _a["substring"];
if (substring === undefined) {
throw (new Error("required parameter missing: substring"));
}
else {
return lib_plankton.log.channel.filtered.predicate_incident(substring);
}
},
"level": function (_a) {
var threshold = _a["threshold"];
if (threshold === undefined) {
throw (new Error("required parameter missing: threshold"));
}
else {
return lib_plankton.log.channel.filtered.predicate_level(log.level_decode(threshold));
}
},
"tag": function (_a) {
var value = _a["value"];
if (value === undefined) {
throw (new Error("required parameter missing: value"));
}
else {
return lib_plankton.log.channel.filtered.predicate_tag(value);
}
}
}, {
"fallback": function () { return function (entry) { return true; }; }
})
});
}); }))
});
break;
}
case "minlevel": {
return lib_plankton.log.channel.minlevel.logic({
"core": get_channel_logic(channel_description.data.core),
"threshold": log.level_decode(channel_description.data.threshold)
});
break;
}
case "console": {
return lib_plankton.log.channel.console_.logic({});
break;
}
}
}
log.get_channel_logic = get_channel_logic;
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
/**
*/
function default_logger() {
return [
{
"kind": "minlevel",
"data": {
"core": {
"kind": "console",
"data": {}
},
"threshold": "info"
}
},
];
}
log.default_logger = default_logger;
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:log«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:log« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:lang« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:log«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var log;
(function (log) {
/**
*/
var _main_logger_data = null;
/**
*/
function set_main_logger(logger_data) {
_main_logger_data = logger_data;
}
log.set_main_logger = set_main_logger;
/**
*/
function get_main_logger() {
return (_main_logger_data !== null && _main_logger_data !== void 0 ? _main_logger_data : log.default_logger());
}
/**
*/
function get_main_logger_logic() {
return lib_plankton.log.get_logger_logic(get_main_logger());
}
/**
* consumes a log entry, i.e. sends it to all channels
*/
function send_(logger, entry) {
logger.forEach(function (channel) { return channel.send(entry); });
}
log.send_ = send_;
/**
* [convenience]
*
* @todo rename to "send"
*/
function debug_(logger, incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
send_(logger, {
"level": log.enum_level.debug,
"incident": incident,
"tags": option_tags,
"details": option_details
});
}
log.debug_ = debug_;
/**
* [convenience]
*
* @todo rename to "info"
*/
function info_(logger, incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
send_(logger, {
"level": log.enum_level.info,
"incident": incident,
"tags": option_tags,
"details": option_details
});
}
log.info_ = info_;
/**
* [convenience]
*
* @todo rename to "notice"
*/
function notice_(logger, incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
send_(logger, {
"level": log.enum_level.notice,
"incident": incident,
"tags": option_tags,
"details": option_details
});
}
log.notice_ = notice_;
/**
* [convenience]
*
* @todo rename to "warning"
*/
function warning_(logger, incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
send_(logger, {
"level": log.enum_level.warning,
"incident": incident,
"tags": option_tags,
"details": option_details
});
}
log.warning_ = warning_;
/**
* [convenience]
*
* @todo rename to "error"
*/
function error_(logger, incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
send_(logger, {
"level": log.enum_level.error,
"incident": incident,
"tags": option_tags,
"details": option_details
});
}
log.error_ = error_;
/**
* [convenience]
*/
function _send(entry) {
send_(get_main_logger_logic(), entry);
}
log._send = _send;
/**
* [convenience]
*/
function _debug(incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
debug_(get_main_logger_logic(), incident, {
"tags": option_tags,
"details": option_details
});
}
log._debug = _debug;
/**
* [convenience]
*/
function _info(incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
info_(get_main_logger_logic(), incident, {
"tags": option_tags,
"details": option_details
});
}
log._info = _info;
/**
* [convenience]
*/
function _notice(incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
notice_(get_main_logger_logic(), incident, {
"tags": option_tags,
"details": option_details
});
}
log._notice = _notice;
/**
* [convenience]
*/
function _warning(incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
warning_(get_main_logger_logic(), incident, {
"tags": option_tags,
"details": option_details
});
}
log._warning = _warning;
/**
* [convenience]
*/
function _error(incident, _a) {
var _b = _a === void 0 ? {} : _a, _c = _b["tags"], option_tags = _c === void 0 ? [] : _c, _d = _b["details"], option_details = _d === void 0 ? null : _d;
error_(get_main_logger_logic(), incident, {
"tags": option_tags,
"details": option_details
});
}
log._error = _error;
/**
* [convenience]
*
* @deprecated use ._debug instead!
*/
function debug(incident, details, tags) {
if (details === void 0) { details = null; }
if (tags === void 0) { tags = []; }
_debug(incident, {
"details": details,
"tags": tags
});
}
log.debug = debug;
/**
* [convenience]
*
* @deprecated use ._info instead!
*/
function info(incident, details, tags) {
if (details === void 0) { details = null; }
if (tags === void 0) { tags = []; }
_info(incident, {
"details": details,
"tags": tags
});
}
log.info = info;
/**
* [convenience]
*
* @deprecated use ._notice instead!
*/
function notice(incident, details, tags) {
if (details === void 0) { details = null; }
if (tags === void 0) { tags = []; }
_notice(incident, {
"details": details,
"tags": tags
});
}
log.notice = notice;
/**
* [convenience]
*
* @deprecated use ._warning instead!
*/
function warning(incident, details, tags) {
if (details === void 0) { details = null; }
if (tags === void 0) { tags = []; }
_warning(incident, {
"details": details,
"tags": tags
});
}
log.warning = warning;
/**
* [convenience]
*
* @deprecated use ._error instead!
*/
function error(incident, details, tags) {
if (details === void 0) { details = null; }
if (tags === void 0) { tags = []; }
_error(incident, {
"details": details,
"tags": tags
});
}
log.error = error;
})(log = lib_plankton.log || (lib_plankton.log = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:string«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:string« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:string« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
*/
var plain_text_to_html = function (text) {
let ret = text;
ret = ret.replace(/ /g, "&nbsp;&nbsp;"); // convert multiple whitespace to forced ones
ret = ret.split("\n").join("<br/>");
return ret;
};
/**
* @desc makes a valid
*/
var format_sentence = function (str, rtl = false, caseSense = true) {
if (str === "") {
return str;
}
else {
let marks = {
".": true,
"?": true,
"!": true
};
let default_mark = ".";
let ret = str.split("");
if (!rtl) {
ret[0] = ret[0].toLocaleUpperCase();
if (!(ret[ret.length - 1] in marks)) {
ret.push(default_mark);
}
}
else {
ret[ret.length - 1] = ret[ret.length - 1].toLocaleUpperCase();
if (!(ret[0] in marks)) {
ret.unshift(default_mark);
}
}
return ret.join("");
}
};
var fill_string_template = function (template_string, object, fabric = function (object, key) { return object[key]; }, delimiter = "%", default_string = null, sloppy) {
function get_tags(str) {
let r = new RegExp(delimiter + "[^\\s^" + delimiter + "]+" + delimiter, "gi");
return ((str.match(r) || []).map(function (e) {
return e.slice(delimiter.length, e.length - delimiter.length);
}));
}
function replace_tag(str, tag, value) {
let r = new RegExp(delimiter + tag + delimiter, "gi");
return str.replace(r, value);
}
function replace_tags(str, obj) {
return (get_tags(str).reduce(function (ret, key) {
let value = "";
try {
value = fabric(obj, key);
if ((!sloppy && (value === void 0)) || (sloppy && (value == void 0))) {
value = default_string;
}
}
catch (e) {
console.warn("invalid placeholder " + key);
value = default_string;
}
return replace_tag(ret, key, value);
}, str));
}
return replace_tags(template_string, object);
};
var make_string_template = function (_template, _fabrics = {}) {
function replace_tag(str, tag, value) {
var r = new RegExp("%" + tag + "%", "gi");
return str.replace(r, value);
}
function replace_tags(str, obj) {
return (Object.keys(obj).reduce(function (ret, key) {
return replace_tag(ret, key, _fabrics[key] || obj[key]);
}, str));
}
return (function (tags) {
return replace_tags(_template, tags);
});
};
var make_eml_header = (function () {
let _template = "";
_template += "From: %from%\n";
_template += "To: %recipient%\n";
_template += "Subject: %subject%\n";
_template += "X-Mailer: greenscale-plankton.emlgen\n";
return make_string_template(_template);
})();
var make_eml_body = (function () {
let exports = {};
exports["simple_body"] = make_string_template("Content-Type: %contenttype%\n\n%body%\n\n");
// very basic implementation
// parts = [{contenttype:"text/html; charset=UTF-8", body: "<h1>foo</h1>" }, {...}]
exports["body_boundrary"] = function (parts, boundrary) {
let _template = "";
_template += "--%boundrary%\n";
_template += "Content-Type: %contenttype%\n\n%body%\n\n";
//_template += "--%boundrary%--\n\n";
let maker = make_string_template(_template);
return (parts.reduce(function (prev, curr) {
curr.boundrary = boundrary;
return [prev, maker(curr)].join("");
}, ""));
};
// body must be base64 encoded!
exports["attachment_boundrary"] = function (parts, boundrary) {
let _template = "";
_template += "--%boundrary%\n";
_template += "Content-Type: %contenttype%\n";
_template += "Content-Transfer-Encoding: base64\n";
_template += "Content-Disposition: %disposition%; filename=\"%name%\"\n\n";
_template += "%body%\n\n";
//_template += "--%boundrary%--\n\n";
let maker = make_string_template(_template);
return (parts.reduce(function (prev, curr) {
curr.boundrary = boundrary;
if (curr.disposition === void 0)
curr.disposition = "inline";
return [prev, maker(curr)].join("");
}, ""));
};
exports["gen_boundrary"] = function () {
return ("xxxxxxxxxxxxxxxxxxxxxx".replace(/[xy]/g, function (c) {
let r = crypto.getRandomValues(new Uint8Array(1))[0] % 16 | 0, v = c == "x" ? r : (r & 0x3 | 0x8);
return v.toString(16);
}));
};
// simple implementation without alternatives (old rfc)
exports["complete_boundrary"] = function (bodyparts, attachments) {
let ret = "";
let boundrary = exports["gen_boundrary"]();
ret += exports["body_boundrary"](bodyparts, boundrary);
ret += exports["attachment_boundrary"](attachments, boundrary);
ret += "--" + boundrary + "--\n\nINVISIBLE!!!!";
return (exports["simple_body"]({
"contenttype": sprintf("multipart/mixed; boundary=%s", [boundrary]),
"body": ret
}));
};
return exports;
})();
/*
This file is part of »bacterio-plankton:string«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:string« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:string« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var string;
(function (string) {
/**
* @author fenris
*/
const hexdigits = 4;
/**
* @author fenris
*/
const index_max = (1 << (4 * hexdigits));
/**
* @author fenris
*/
var index_is = 0;
/**
* @author neuc,frac
*/
function empty(str) {
return (str.trim() === "");
}
string.empty = empty;
/**
* @desc returns a unique string
* @param {string} prefix an optional prefix for the generated string
* @return {string}
* @author fenris
*/
function generate(prefix = "string_") {
if (index_is > index_max) {
lib_plankton.log.error("plankton.string.generate.out_of_valid_indices", null);
throw (new Error("[string_generate] out of valid indices"));
}
else {
return string.sprintf(prefix + "%0" + hexdigits.toString() + "X", [index_is++]);
}
}
string.generate = generate;
/**
* @author fenris
*/
function join(parts, glue = " ") {
if (parts.length == 0) {
return "";
}
else {
return parts.join(glue);
}
}
string.join = join;
/**
* @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, separator) {
if (chain.length == 0) {
return [];
}
else {
return chain.split(separator);
}
}
string.split = split;
/**
* @author neu3no
*/
function explode(str, needle, max) {
let temp = str.split(needle);
const right = temp.splice(max - 1);
temp.push(right.join(needle));
return temp;
}
string.explode = explode;
/**
* @desc concats a given word with itself n times
* @param {string} word
* @param {int}
* @return {string}
* @author fenris
*/
function repeat(word, count) {
// return ((count == 0) ? "" : (word + repeat(word, count-1)));
let result = "";
for (let n = 0; n < count; n += 1) {
result += word;
}
return result;
}
string.repeat = repeat;
/**
* @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, length, symbol = " ", mode = "append") {
switch (mode) {
case "prepend": {
// insert symbols only at the beginning
while (word.length < length)
word = symbol + word;
return word.substring(word.length - length);
break;
}
case "append": {
// insert symbols only at the end
while (word.length < length)
word = word + symbol;
return word.substring(0, length);
break;
}
case "widen": {
// insert symbols at both sides
let left = (((length - word.length) & 1) === 0);
while (word.length < length) {
word = (left
? (symbol + word)
: (word + symbol));
left = (!left);
}
return word.substring(0, length);
break;
}
default: {
const message = ("unhandled mode '" + mode + "'");
console.warn(message);
return word;
break;
}
}
}
string.pad = pad;
/**
* @desc checks if a given string conttains a certain substring
* @param {string} string
* @param {string} part
* @return {boolean}
* @author fenris
*/
function contains(chain, part) {
if (typeof (chain) !== "string") {
return false;
}
return (chain.indexOf(part) >= 0);
}
string.contains = contains;
/**
* @desc checks if a given string starts with a certain substring
* @param {string} string
* @param {string} part
* @return {boolean}
* @author fenris
*/
function startsWith(chain, part) {
if (typeof (chain) !== "string") {
return false;
}
// return (string.indexOf(part) === 0);
return ((function (m, n) {
if (n === 0) {
return true;
}
else {
if (m === 0) {
return false;
}
else {
return ((chain[0] == part[0])
&&
startsWith(chain.substring(1), part.substring(1)));
}
}
})(chain.length, part.length));
}
string.startsWith = startsWith;
/**
* @desc checks if a given string ends with a certain substring
* @param {string} string
* @param {string} part
* @return {boolean}
* @author fenris
*/
function endsWith(chain, part) {
if (typeof (chain) !== "string") {
return false;
}
// return (string.lastIndexOf(part) === string.length-part.length);
return ((function (m, n) {
if (n === 0) {
return true;
}
else {
if (m === 0) {
return false;
}
else {
// console.info(("(" + string[m-1] + " == " + part[n-1] + ")") + " = " + String(string[m-1] == part[n-1]));
return ((chain[m - 1] === part[n - 1])
&&
endsWith(chain.substring(0, m - 1), part.substring(0, n - 1)));
}
}
})(chain.length, part.length));
}
string.endsWith = endsWith;
/**
* @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, needle_string, check_escape) {
let cnt = 0;
let pos = -1;
do {
pos = haystack_string.indexOf(needle_string, pos + 1);
if ((!check_escape) || (haystack_string[pos - 1] != "\\")) {
cnt++;
}
} while (pos >= 0);
return (cnt - 1);
}
string.count_occourrences = count_occourrences;
/**
* @author fenris
*/
function replace(str, replacements, options = {}) {
options = Object.assign({}, options);
let result = str;
replacements.forEach(replacement => {
lib_plankton.log.debug("lib_plankton.string.replace", {
"from": replacement.from,
"to": replacement.to,
});
result = result.replace(new RegExp(replacement.from, "g"), replacement.to);
});
return result;
}
string.replace = replace;
/**
* @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object
* @author fenris
*/
function coin(str, args, options = {}) {
options = Object.assign({
"legacy": false,
"open": "{{",
"close": "}}",
}, options);
Object.keys(args).forEach((key) => {
// old syntax
{
if (options.legacy) {
const value = args[key];
const regexp_argument = new RegExp("\\${" + key + "}", "g");
/*
lib_plankton.log.debug(
"lib_plankton.string.coin",
{
"key": key,
"regex": regexp_argument.toString(),
"value": value,
}
);
*/
str = str.replace(regexp_argument, value);
}
}
// new syntax
{
const value = args[key];
const regexp_argument = new RegExp(options.open + key + options.close, "g");
/*
lib_plankton.log.debug(
"lib_plankton.string.coin",
{
"key": key,
"regex": regexp_argument.toString(),
"value": value,
}
);
*/
str = str.replace(regexp_argument, value);
}
});
return str;
}
string.coin = coin;
/**
* @author fenris
* @deprecated use limit
*/
function cut(str, length, delimiter = "…") {
if (str.length <= length) {
return str;
}
else {
return (str.slice(0, length - delimiter.length) + delimiter);
}
}
string.cut = cut;
/**
*/
function limit(str, options = {}) {
options = Object.assign({
"length": 120,
"indicator": "…",
}, options);
return ((str.length <= options.length)
? str
: (str.slice(0, options.length - options.indicator.length) + options.indicator));
}
string.limit = limit;
/**
*/
function slice(str, size) {
let slices = [];
let rest = str;
while (rest.length > 0) {
slices.push(rest.slice(0, size));
rest = rest.slice(size);
}
return slices;
}
string.slice = slice;
/**
*/
function capitalize(str) {
return (str[0].toUpperCase() + str.slice(1));
}
string.capitalize = capitalize;
})(string = lib_plankton.string || (lib_plankton.string = {}));
})(lib_plankton || (lib_plankton = {}));
/**
* @deprecated
*/
var lib_string;
(function (lib_string) {
lib_string.empty = lib_plankton.string.empty;
lib_string.generate = lib_plankton.string.generate;
lib_string.split = lib_plankton.string.split;
lib_string.explode = lib_plankton.string.repeat;
lib_string.repeat = lib_plankton.string.repeat;
lib_string.pad = lib_plankton.string.pad;
lib_string.contains = lib_plankton.string.contains;
lib_string.startsWith = lib_plankton.string.startsWith;
lib_string.endsWith = lib_plankton.string.endsWith;
lib_string.count_occourrences = lib_plankton.string.count_occourrences;
lib_string.coin = lib_plankton.string.coin;
lib_string.stance = lib_plankton.string.coin;
lib_string.cut = lib_plankton.string.cut;
})(lib_string || (lib_string = {}));
/*
This file is part of »bacterio-plankton:string«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:string« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:string« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var string;
(function (string) {
var pattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/;
var gpattern = /%([-+#0 ]*)([0-9]*)[\.]{0,1}([0-9]*)([\w]{1})/g;
function split_format(format) {
var tmp = format.match(pattern);
if (tmp === null)
return null;
return {
'flags': tmp[1].split(""),
'width': Number(tmp[2]),
'precision': tmp[3] === '' ? null : Number(tmp[3]),
'specifier': tmp[4],
'string': format
};
}
function make_err(format, arg, should) {
return ("[sprintf]" + " " + "argument for '" + format.string + "' has to be '" + should + "' but '" + arg + "' is '" + typeof arg + "'!");
}
function test_arg(format, arg, should) {
if (typeof arg !== should) {
console.warn(make_err(format, arg, should));
return false;
}
return true;
}
function string_fill(str, char, len, left) {
while (str.length < len) {
if (left) {
str += char;
}
else {
str = char + str;
}
}
return str;
}
/**
* the known_parameters are used to parse the different identifiers for the welln known syntax:
* flag width precision identifier
* %{[0#+- ]}{[0-9]*}.{[0-9]*}[fFdiueEgGsoxXaAsn]
* flags:
* 0 - fill with '0' instead of ' ' if the string length < width
* # - not implemented
* - - left-justified -> fill on the right side to reach width
* + - force using '+' on positive numbers
* ' ' - add a single space before positive numbers
*
* identifiers
* %f, %F - interpret given number as float, width: the minimal total width (fill with ' ' or '0' if the
* resulting string is too short, precision: cut more then given decimal places
* %d, %i, %u - interpret number as integer, decimal places will be cut. width: like float, precision:
* fill with '0' on right side until length given in precision is reached
* %e - interpret as float and write as scientifical number, width & precision like in float
* %E - same es %e but uppercase 'E'
* %g - use the shortest string of %f or %e
* %G - use the shortest string of %E or %E
* %s - simply print a string
* %o - print the given number in octal notation
* %x - print the given number in hex notation
* %X - same as %x but with uppercase characters
* %a - alias to %x
* %A - alias to %X
* %n - just print nothing
* @type {{}}
*/
var known_params = {};
known_params["f"] = function (format, arg) {
if (!test_arg(format, arg, "number"))
return "Ø";
var tmp = Math.abs(arg);
var sign = (arg < 0) ? -1 : 1;
var tmp_result = null;
if (format.precision !== null) {
tmp = Math.floor(Math.pow(10, format.precision) * tmp) / Math.pow(10, format.precision);
var tmp_ = (tmp * sign).toString().split(".");
if (tmp_.length === 1)
tmp_.push("");
tmp_[1] = string_fill(tmp_[1], "0", format.precision, true);
tmp_result = tmp_.join(".");
}
else {
tmp_result = (sign * tmp).toString();
}
if ((format.flags.indexOf(" ") >= 0) && (arg >= 0)) {
tmp_result = " " + tmp;
}
else if ((format.flags.indexOf("+") >= 0) && (arg >= 0)) {
tmp_result = "+" + tmp;
}
tmp_result = string_fill(tmp, (format.flags.indexOf("0") >= 0) ? "0" : " ", format.width, (format.flags.indexOf("-") >= 0));
return tmp_result;
};
known_params["F"] = known_params["f"];
known_params["d"] = function (format, arg) {
if (!test_arg(format, arg, 'number'))
return 'Ø';
var tmp = (((arg < 0 && format.specifier !== 'u') ? -1 : 1) * Math.floor(Math.abs(arg))).toString();
if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf(' ') >= 0 && arg >= 0) {
tmp = ' ' + tmp;
}
else if ((format.specifier === 'd' || format.specifier === 'i') && format.flags.indexOf('+') >= 0 && arg >= 0) {
tmp = '+' + tmp;
}
tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
tmp = string_fill(tmp, '0', format.precision === null ? 0 : format.precision, false);
return tmp;
};
known_params["i"] = known_params["d"];
known_params["u"] = known_params["d"];
known_params["e"] = function (format, arg) {
if (!test_arg(format, arg, 'number'))
return 'Ø';
var tmp = arg.toExponential(format.precision === null ? undefined : format.precision).toString();
if (format.flags.indexOf(' ') >= 0 && arg >= 0) {
tmp = ' ' + tmp;
}
else if (format.flags.indexOf('+') >= 0 && arg >= 0) {
tmp = '+' + tmp;
}
tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
return tmp;
};
known_params["E"] = function (format, arg) {
return known_params["e"](format, arg).toUpperCase();
};
known_params["g"] = function (format, arg) {
if (!test_arg(format, arg, 'number'))
return 'Ø';
var tmpf = known_params["f"](format, arg);
var tmpe = known_params["e"](format, arg);
if (tmpf.length < tmpe.length) {
return tmpf;
}
else {
return tmpe;
}
};
known_params["G"] = function (format, arg) {
return known_params["g"](format, arg).toUpperCase();
};
known_params["s"] = function (format, arg) {
if (!test_arg(format, arg, 'string'))
return 'o.O';
var tmp = format.precision !== null ? arg.substr(0, format.precision) : arg;
tmp = string_fill(tmp, format.flags.indexOf('0') >= 0 ? '0' : ' ', format.width, format.flags.indexOf('-') >= 0);
return tmp;
};
known_params["o"] = function (format, arg) {
if (!test_arg(format, arg, 'number'))
return 'Ø';
var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
return known_params["s"](format, tmp.toString(8));
};
known_params["x"] = function (format, arg) {
if (!test_arg(format, arg, 'number'))
return 'Ø';
var tmp = Math.floor(Math.round(Math.abs(arg))) * ((arg < 0) ? -1 : 1);
return known_params["s"](format, tmp.toString(16));
};
known_params["a"] = known_params["x"];
known_params["X"] = function (format, arg) {
if (!test_arg(format, arg, 'number'))
return 'Ø';
return known_params["x"](format, arg).toUpperCase();
};
known_params["A"] = known_params["X"];
known_params["c"] = function (format, arg) {
var tmp = "";
if (typeof arg === "number") {
tmp = String.fromCharCode(arg);
}
else if ((typeof arg === "string") && (arg.length === 1)) {
tmp = arg[0];
}
else {
console.warn(make_err(format, arg, "number|string") + " and if string it needs to have the length of 1!");
}
return known_params["s"](format, tmp);
};
known_params["n"] = function () {
return "";
};
var decompose = function (chain, regexp) {
var result = regexp.exec(chain);
if (result == null) {
return null;
}
else {
var front = chain.substring(0, result.index);
var back = chain.substring(result.index + result[0].length);
return { "front": front, "match": result[0], "back": back };
}
};
/**
* an implementation of c sprintf
* @param {string} string format string
* @param {array} args arguments which should be filled into
* @returns {string}
*/
string.sprintf = function (input, args = [], original = null) {
if (original == null)
original = input;
var components = decompose(input, pattern);
if (components == null) {
if (args.length > 0) {
console.warn("[sprintf] superfluous arguments while formatting '" + original + "': ", args);
}
return input;
}
else {
var arg;
var rest;
if (args.length > 0) {
arg = args[0];
rest = args.slice(1);
}
else {
console.warn("[sprintf] out of arguments while formatting '" + original + "'");
arg = null;
rest = [];
return input;
}
var fmt = split_format(components["match"]);
return (components["front"]
+ known_params[fmt.specifier](fmt, arg)
+ string.sprintf(components["back"], rest, original));
}
};
/**
* an implementation of c printf
* @param {string} string format string
* @param {array} args arguments which should be filled into
* @returns {string}
*/
function printf(format, args) {
console.log(string.sprintf(format, args));
}
string.printf = printf;
})(string = lib_plankton.string || (lib_plankton.string = {}));
})(lib_plankton || (lib_plankton = {}));
var sprintf = lib_plankton.string.sprintf;
var printf = lib_plankton.string.printf;
/*
This file is part of »bacterio-plankton:string«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:string« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:string« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:string«. If not, see <http://www.gnu.org/licenses/>.
*/
var make_logger = (function () {
var _loggers = {};
var make_logger = function (prefix, current_loglevel) {
var log = [];
var level = [
"LOG", "INFO", "WARNING", "DEBUG"
];
var logger = function (obj, lvl) {
var txt = obj.txt || obj;
if (lvl == void 0)
lvl = 0;
var date = new Date();
log.push({
"message": sprintf("%s [%s:%s] %s", [date.toString(), level[lvl], prefix, txt]),
"timeStamp": +(date)
});
if (lvl <= current_loglevel) {
var msg = ["[" + prefix + "]", txt];
if (obj.arg)
msg = ["[" + prefix + "]"].concat(Array.prototype.slice.call(obj.arg));
if (lvl === 0)
console["_log"].apply(console, msg);
else if (lvl === 1)
console["_info"].apply(console, msg);
else if (lvl === 2)
console["_warn"].apply(console, msg);
else if (lvl >= 3)
console["_log"].apply(console, msg);
}
};
_loggers[prefix] = {
"logger": logger,
"log": log
};
return logger;
};
make_logger["loggers"] = _loggers;
make_logger["complete_log"] = function () {
var logs = Object.keys(_loggers)
.reduce(function (p, c) {
return [].concat(p, _loggers[c].log);
}, []);
logs.sort(function (x, y) {
return ((x.timeStamp > y.timeStamp) ? -1 : +1);
});
return logs.map(function (x, i, a) {
return x.message;
});
};
if ( /*!track_exports*/true) {
var _log_all = function (log, lvl, next = function () { }) {
return function () {
var msg = [];
for (var i = 0; i < arguments.length; i++) {
if (typeof arguments[i] === "string") {
msg.push(arguments[i]);
}
else {
msg.push(JSON.stringify(arguments[i]));
}
}
var obj = {
txt: msg.join("\t"),
arg: arguments
};
log(obj, lvl);
next();
};
};
{
var __warn = make_logger("deprecated console.warn", 99);
var __error = make_logger("deprecated console.error", 99);
var __log = make_logger("deprecated console.log", 99);
var __info = make_logger("deprecated console.info", 99);
// bad ass
console["_log"] = console.log;
console["_error"] = console.error;
console["_warn"] = console.warn;
console["_info"] = console.info;
/*
console["log"] = _log_all(__log, 0);
console["error"] = _log_all(__error, 2);
console["warn"] = _log_all(__warn, 2);
console["info"] = _log_all(__info, 0);
*/
}
/*
{
make_logger["send_log"] = function(){
eml_log(
function () {
alert("fehlerbericht wurde gesendet!");
}
);
};
var error_log = make_logger("global.error", 99);
window.onerror = _log_all(
error_log,
1,
function(){
if (global_config == undefined) {
return false;
}
if (global_config.report_error) {
make_logger["send_log"]();
}
}
);
}
*/
}
return make_logger;
})();
/*
This file is part of »bacterio-plankton:object«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:object« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:object« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:object«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var object;
(function (object_1) {
/**
* @author fenris
* @deprecated use the "??" operator instead
*/
function fetch(object, fieldname, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"fallback": null,
"escalation": 1
}, options);
if ((fieldname in object)
&&
(object[fieldname] !== undefined)) {
return object[fieldname];
}
else {
if (!options.escalate) {
return options.fallback;
}
else {
throw (new Error("field '" + fieldname + "' not in structure"));
}
}
}
object_1.fetch = fetch;
/**
*/
function map(object_from, transformator) {
return (Object.fromEntries(Object.entries(object_from)
.map(function (_a) {
var key = _a[0], value = _a[1];
return ([key, transformator(value, key)]);
})));
}
object_1.map = map;
/**
* gibt ein Objekt mit bestimmten Einträgen des Eingabe-Objekts zurück
*/
function filter(object_from, predicate) {
return (Object.fromEntries(Object.entries(object_from)
.filter(function (_a) {
var key = _a[0], value = _a[1];
return predicate(value, key);
})));
}
object_1.filter = filter;
/**
* wandelt ein Array mit Einträgen der Form {key,value} in ein entsprechendes Objekt um
*
* @deprecated use Object.fromEntries instead!
*/
function from_array(array) {
return (Object.fromEntries(array
.map(function (_a) {
var key = _a["key"], value = _a["value"];
return ([key, value]);
})));
}
object_1.from_array = from_array;
/**
* wandelt ein Objekt in ein entsprechendes Array mit Einträgen der Form {key,value} um
*
* @deprecated use Object.entries insetad!
*/
function to_array(object) {
return (Object.entries(object)
.map(function (_a) {
var key = _a[0], value = _a[1];
return ({ "key": key, "value": value });
}));
}
object_1.to_array = to_array;
/**
* gibt eine Liste von Schlüsseln eines Objekts zurück
*
* @deprecated use Object.keys instead!
*/
function keys(object) {
return Object.keys(object);
}
object_1.keys = keys;
/**
* gibt eine Liste von Werten eines Objekts zurück
*
* @deprecated use Object.values instead!
*/
function values(object) {
return Object.values(object);
}
object_1.values = values;
/**
* liest ein Baum-artiges Objekt an einer bestimmten Stelle aus
*/
function path_read(object, path, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"fallback": null,
"escalate": false
}, options);
var steps = ((path.length == 0) ? [] : path.split("."));
if (steps.length == 0) {
throw (new Error("empty path"));
}
else {
var position_1 = object;
var reachable = ((position_1 != null)
&&
(steps.slice(0, steps.length - 1)
.every(function (step) {
position_1 = lib_plankton.object.fetch(position_1, step, {
"fallback": null,
"escalate": false
});
return (position_1 != null);
})));
if (reachable) {
return lib_plankton.object.fetch(position_1, steps[steps.length - 1], {
"fallback": options.fallback,
"escalate": options.escalate
});
}
else {
return lib_plankton.object.fetch({}, "_dummy_", {
"fallback": options.fallback,
"escalate": options.escalate
});
}
}
}
object_1.path_read = path_read;
/**
* schreibt einen Wert an eine bestimmte Stelle in einem Baum-artigen Objekt
*/
function path_write(object, path, value, construct) {
if (construct === void 0) { construct = true; }
var steps = ((path.length == 0) ? [] : path.split("."));
if (steps.length == 0) {
throw (new Error("empty path"));
}
else {
var position_2 = object;
var reachable = steps.slice(0, steps.length - 1).every(function (step) {
var position_ = lib_plankton.object.fetch(position_2, step, {
"fallback": null,
"escalate": false
});
if (position_ == null) {
if (construct) {
position_2[step] = {};
position_2 = position_2[step];
return true;
}
else {
return false;
}
}
else {
position_2 = position_;
return true;
}
});
if (reachable) {
position_2[steps[steps.length - 1]] = value;
}
else {
throw (new Error("path '" + path + "' does not exist and may not be constructed"));
}
}
}
object_1.path_write = path_write;
/**
* prüft ob ein Objekt einem bestimmten Muster entspricht
*
* @deprecated not very useful
*/
function matches(object, pattern, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"collate": instance_collate
}, options);
return (Object.entries(pattern)
.every(function (_a) {
var key = _a[0], value = _a[1];
return options.collate(value, object[key]);
}));
}
object_1.matches = matches;
/**
* erzeugt eine Projektion eines Baum-artigen Objekts in ein Listen-artiges Objekt
*/
function flatten(value, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"separator": ".",
"key_for_array_element": (function (index) { return ("element_" + index.toFixed(0)); })
}, options);
var integrate = function (result, key, value) {
if (value == null) {
result[key] = value;
}
else {
// primitive Werte direkt übernehmen
if (typeof (value) != "object") {
result[key] = value;
}
// sonst durch rekursiven Aufruf die flache Variante des Wertes ermitteln und einarbeiten
else {
var result_ = flatten(value, {
"separator": options.separator,
"key_for_array_element": options.key_for_array_element
});
Object.entries(result_).forEach(function (_a) {
var key_ = _a[0], value_ = _a[1];
result[(key + options.separator + key_)] = value_;
});
}
}
};
if ((value === null)
||
(value === undefined)) {
return null;
}
else {
var result_1 = {};
if (typeof (value) != "object") {
result_1["value"] = value;
}
else {
if (value instanceof Array) {
value.forEach(function (element, index) {
integrate(result_1, options.key_for_array_element(index), element);
});
}
else {
Object.entries(value).forEach(function (_a) {
var key = _a[0], value = _a[1];
integrate(result_1, key, value);
});
}
}
return result_1;
}
}
object_1.flatten = flatten;
/**
* @deprecated use Object.assign instead!
*/
function clash(x, y, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"overwrite": true,
"hooks": {
"existing": function (key, value_old, value_new) {
lib_plankton.log.warning("object_clash_field_already_defined", {
"key": key
});
}
}
}, options);
var z = {};
Object.keys(x).forEach(function (key) {
z[key] = x[key];
});
Object.keys(y).forEach(function (key) {
if (key in z) {
if (options.hooks.existing != null) {
options.hooks.existing(key, z[key], y[key]);
}
if (options.overwrite) {
z[key] = y[key];
}
}
else {
z[key] = y[key];
}
});
return z;
}
object_1.clash = clash;
/**
* @deprecated use Object.assign instead!
*/
function patch(core, mantle, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"deep": true,
"path": null
}, options);
if (mantle == null) {
lib_plankton.log.warning("object_patch_mantle_is_null", {
"core": core
});
}
else {
Object.keys(mantle).forEach(function (key) {
var path_ = ((options.path == null)
?
key
:
(options.path + "." + key));
var value_mantle = mantle[key];
if (!(key in core)) {
if ((typeof (value_mantle) == "object")
&&
(value_mantle != null)
&&
options.deep) {
if (value_mantle instanceof Array) {
core[key] = [];
value_mantle.forEach(function (element) {
if ((typeof (element) == "object")
&&
(element != null)) {
var element_ = {};
patch(element_, element);
core[key].push(element_);
}
else {
core[key].push(element);
}
});
}
else {
core[key] = {};
patch(core[key], value_mantle, {
"deep": options.deep,
"path": path_
});
}
}
else {
core[key] = value_mantle;
}
}
else {
var value_core = core[key];
if (typeof (value_core) == typeof (value_mantle)) {
if ((typeof (value_mantle) == "object")
&&
(value_mantle != null)
&&
options.deep) {
patch(core[key], value_mantle, {
"deep": options.deep,
"path": path_
});
}
else {
core[key] = value_mantle;
}
}
else {
if ((value_core != null)
&&
(value_mantle != null)) {
lib_plankton.log.warning("object_path_different_shapes", {
"path": path_,
"core_type": typeof (value_core),
"mantle_type": typeof (value_mantle)
});
}
core[key] = value_mantle;
// throw (new Error(message));
}
}
});
}
}
object_1.patch = patch;
/**
* @deprecated use Object.assign instead!
*/
function patched(core, mantle, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"deep": true
}, options);
var result = {};
patch(result, core, { "deep": options.deep });
patch(result, mantle, { "deep": options.deep });
return result;
}
object_1.patched = patched;
/**
* @deprecated use Object.assign instead!
*/
function attached(object, key, value) {
var mantle = {};
mantle[key] = value;
return patched(object, mantle, { "deep": false });
}
object_1.attached = attached;
/**
* @author fenris
*/
function copy(object) {
return patched({}, object);
}
object_1.copy = copy;
})(object = lib_plankton.object || (lib_plankton.object = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:translate«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:translate« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:translate« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:translate«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var translate;
(function (translate) {
/**
* @desc contains the sets of strings
* @author fenris
*/
var _packages = {};
/**
* @desc specifies in which order the languages shall be queried; if getting a string from language #0 fails, the
* system tries to get it from language #1, and so on
* @author fenris
*/
var _order = [];
/**
* @desc whether to automatically promote the language of a newly added package
* @author fenris
*/
var _autopromote = false;
/**
* @desc the level of verbosity, specifiying how much output the system shall provide about its actions
* @author fenris
*/
translate._verbosity = 1;
/**
* @desc which initial string to use for log-outputs
* @author fenris
*/
var _logprefix = "[lib_translate]";
/**
* @desc moves a language to the top of the order, making it the primary one
* @author fenris
*/
function promote(identifier) {
if (Object.keys(_packages).indexOf(identifier) < 0) {
if (translate._verbosity >= 1) {
console.warn(`${_logprefix} package '${identifier}' doesn't exist yet`);
}
}
let position = _order.indexOf(identifier);
if (position >= 0) {
if (translate._verbosity >= 2) {
console.info(`${_logprefix} '${identifier}' already in order; will promote it`);
}
_order.splice(position, 1);
}
_order.unshift(identifier);
if (translate._verbosity >= 2) {
console.info(`${_logprefix} order is now ${_order.toString()}`);
}
}
translate.promote = promote;
/**
* @desc adds a package to the sytem
* @author fenris
*/
function add(package_) {
let identifier = package_.meta.identifier;
if (identifier in _packages) {
if (translate._verbosity >= 1) {
console.warn(`${_logprefix} package '${identifier}' has already been added; will overwrite`);
}
}
else {
if (translate._verbosity >= 2) {
console.log(`${_logprefix} got package '${identifier}'`);
}
}
_packages[identifier] = package_;
if (_autopromote) {
promote(identifier);
}
}
translate.add = add;
/**
* @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_) {
let identifier = package_.meta.identifier;
if (identifier in _packages) {
lib_plankton.object.patch(_packages[identifier].tree, package_.tree, {
"deep": true,
});
}
else {
if (translate._verbosity >= 2) {
console.info(`${_logprefix} package '${identifier}' didn't exist so far; will create it now`);
}
add(package_);
}
}
translate.feed = feed;
/**
* @desc tries to retrieve a translation for a specific package identifier
* @author fenris
*/
function fetch(identifier, path, args = {}) {
if (!(identifier in _packages)) {
if (translate._verbosity >= 1) {
console.warn(`${_logprefix} no package '${identifier}'`);
}
return (lib_plankton.pod.make_empty());
}
else {
// let str : string = lib_plankton.object.path_read<string>(_packages[identifier].tree, path);
let str = _packages[identifier].tree[path];
if (str == undefined) {
if (translate._verbosity >= 1) {
console.warn(`${_logprefix} string '${path}' missing in package '${identifier}'`);
}
return (lib_plankton.pod.make_empty());
}
else {
// resolve references
{
let regexp_reference = new RegExp("#\\(([\\w\\.]*)(?:\\?(\\w+)=(\\w+)(?:&(\\w+)=(\\w+))*)?\\)");
while (true) {
let matching = regexp_reference.exec(str);
if (matching != null) {
let path_ = matching[1];
let args_ = {};
if (translate._verbosity >= 2) {
// console.info(`${_logprefix} found reference to '${path_}' with args ${JSON.stringify(args_)}`);
console.info(`${_logprefix} found reference to '${path_}'`);
}
// parse args
{
for (let index = 2; index <= matching.length - 1; index += 2) {
let id = matching[index + 0];
let value = matching[index + 1];
if (id != undefined) {
args_[id] = value;
}
}
}
// fetch referenced string
{
let result_ = fetch(identifier, path_, args_);
if (lib_plankton.pod.is_filled(result_)) {
let front = str.slice(0, matching.index);
let back = str.slice(matching.index + matching[0].length);
str = (front + lib_plankton.pod.cull(result_) + back);
}
else {
return (lib_plankton.pod.make_empty());
break;
}
}
}
else {
break;
}
}
}
// insert arguments
{
str = lib_plankton.string.coin(str, args);
}
return (lib_plankton.pod.make_filled(str));
}
}
}
translate.fetch = fetch;
/**
* @desc retrieves a string by going through the order and trying to fetch it for the current entry
* @author fenris
*/
function get(path, args = {}, fallback = null) {
if (fallback == null) {
fallback = `{${path}}`;
}
if (translate._verbosity >= 2) {
console.info(`${_logprefix} getting translation for string '${path}' with arguments ${JSON.stringify(args)} …`);
}
let result = lib_plankton.pod.make_empty();
let found = _order.some(identifier => {
if (translate._verbosity >= 2) {
console.info(`${_logprefix} trying package '${identifier}' …`);
}
let result_ = fetch(identifier, path, args);
if (lib_plankton.pod.is_filled(result_)) {
result = result_;
return true;
}
else {
return false;
}
});
if (found) {
let str = lib_plankton.pod.cull(result);
if (translate._verbosity >= 3) {
console.info(`${_logprefix} found translation: '${str}'`);
}
return str;
}
else {
let str = fallback;
if (translate._verbosity >= 1) {
console.warn(`${_logprefix} no package provides a translation for string '${path}'; will use the fallback translation '${str}'`);
}
return str;
}
}
translate.get = get;
/**
* @author fenris
*/
function list() {
return lib_plankton.object.to_array(_packages).map(x => x.value.meta);
}
translate.list = list;
/**
* @author fenris
* @todo get rid of this; it's currenly needed only for the cdh-internal lib_completion
*/
function paths() {
return lib_plankton.object.keys(lib_plankton.object.flatten(_packages[_order[0]].tree));
}
translate.paths = paths;
/**
* @author fenris
*/
function initialize({ "logprefix": logprefix = undefined, "verbosity": verbosity = undefined, "packages": packages = [], "order": order = undefined, "autopromote": autopromote = undefined, } = {}) {
return (Promise.resolve(undefined)
// set variables
.then(_ => {
if (logprefix != undefined)
_logprefix = logprefix;
if (verbosity != undefined)
translate._verbosity = verbosity;
// _packages = {};
if (order != undefined)
_order = order;
if (autopromote != undefined)
_autopromote = autopromote;
return Promise.resolve(undefined);
})
// feed
.then(_ => {
packages.forEach(feed);
return Promise.resolve(undefined);
}));
}
translate.initialize = initialize;
})(translate = lib_plankton.translate || (lib_plankton.translate = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:translate«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:translate« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:translate« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:translate«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var translate;
(function (translate) {
/**
* @author fenris
*/
function iso_639_1_to_iso_639_2(iso6391) {
let mapping = {
"af": "afr",
"ar": "ara",
"bg": "bul",
"cs": "ces",
"da": "dan",
"de": "deu",
"el": "ell",
"en": "eng",
"eo": "epo",
"es": "esp",
"fa": "fas",
"fi": "fin",
"fr": "fra",
"hi": "hin",
"hr": "hrv",
"hu": "hun",
"is": "isl",
"it": "ita",
"ja": "jpn",
"ko": "kor",
"nb": "nob",
"nl": "nld",
"nn": "nno",
"pt": "por",
"pl": "pol",
"ro": "ron",
"ru": "rus",
"sk": "slk",
"sv": "swe",
"zh": "zho",
};
return mapping[iso6391];
}
translate.iso_639_1_to_iso_639_2 = iso_639_1_to_iso_639_2;
/**
* @author fenris
*/
function stance(str) {
let regexp = new RegExp("^translate:(.*)$");
let matching = regexp.exec(str);
if (matching != null) {
return translate.get(matching[1]);
}
else {
return str;
}
}
translate.stance = stance;
})(translate = lib_plankton.translate || (lib_plankton.translate = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:database«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:database« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:database« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:database«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var database;
(function (database) {
/**
*/
let enum_type;
(function (enum_type) {
enum_type["boolean"] = "boolean";
enum_type["integer"] = "integer";
enum_type["string_short"] = "string_short";
enum_type["string_medium"] = "string_medium";
enum_type["string_long"] = "string_long";
enum_type["float"] = "float";
})(enum_type = database.enum_type || (database.enum_type = {}));
})(database = lib_plankton.database || (lib_plankton.database = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:storage«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:storage« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file is part of »bacterio-plankton:storage«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:storage« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file is part of »bacterio-plankton:storage«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:storage« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var storage;
(function (storage) {
var memory;
(function (memory) {
/**
* @author fenris
*/
function make(parameters) {
return {
"data": {}
};
}
memory.make = make;
/**
* @author fenris
*/
function clear(subject) {
subject.data = {};
}
memory.clear = clear;
/**
* @author fenris
*/
function write(subject, key, value) {
var exists = (key in subject.data);
subject.data[key] = value;
return exists;
}
memory.write = write;
/**
* @author fenris
*/
function delete_(subject, key) {
if (!(key in subject.data)) {
throw (new Error("no value for key '" + key + "'"));
}
else {
delete subject.data[key];
}
}
memory.delete_ = delete_;
/**
* @author fenris
*/
function read(subject, key) {
if (!(key in subject.data)) {
throw (new Error("no value for key '" + key + "'"));
}
else {
return subject.data[key];
}
}
memory.read = read;
/**
* @author fenris
*/
function list(subject) {
return Object.keys(subject.data);
}
memory.list = list;
/**
* @author fenris
*/
function search(subject, term) {
return (list(subject)
.map(function (key) { return ({ "key": key, "preview": key }); }));
}
memory.search = search;
/**
* @author fenris
*/
function implementation_chest(parameters) {
function wrap(core) {
return (new Promise(function (resolve, reject) { resolve(core()); }));
}
var subject = make(parameters);
return {
"setup": function (input) { return Promise.resolve(undefined); },
"clear": function () { return wrap(function () { return clear(subject); }); },
"write": function (key, value) { return wrap(function () { return write(subject, key, value); }); },
"delete": function (key) { return wrap(function () { return delete_(subject, key); }); },
"read": function (key) { return wrap(function () { return read(subject, key); }); },
"search": function (term) { return wrap(function () { return search(subject, term); }); }
};
}
memory.implementation_chest = implementation_chest;
})(memory = storage.memory || (storage.memory = {}));
})(storage = lib_plankton.storage || (lib_plankton.storage = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:storage«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:storage« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var storage;
(function (storage) {
var memory;
(function (memory) {
/**
* @author fenris
*/
var class_chest = /** @class */ (function () {
function class_chest(parameters) {
this.subject = memory.make(parameters);
}
class_chest.prototype.setup = function (input) { return Promise.resolve(undefined); };
class_chest.prototype.clear = function () { memory.clear(this.subject); return Promise.resolve(undefined); };
class_chest.prototype.write = function (key, value) { return Promise.resolve(memory.write(this.subject, key, value)); };
class_chest.prototype["delete"] = function (key) { memory.delete_(this.subject, key); return Promise.resolve(undefined); };
class_chest.prototype.read = function (key) { return Promise.resolve(memory.read(this.subject, key)); };
class_chest.prototype.search = function (term) { return Promise.resolve(memory.search(this.subject, term)); };
return class_chest;
}());
memory.class_chest = class_chest;
})(memory = storage.memory || (storage.memory = {}));
})(storage = lib_plankton.storage || (lib_plankton.storage = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:storage«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:storage« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var storage;
(function (storage) {
var localstorage;
(function (localstorage) {
/**
* @author fenris
*/
function make(parameters) {
parameters = Object.assign({
"corner": "plankton"
}, parameters);
return {
"corner": parameters.corner
};
}
localstorage.make = make;
/**
*/
function compose_full_key(subject, key) {
return (subject.corner + "_" + key);
}
/**
*/
function decompose_full_key(subject, full_key) {
var parts = full_key.split("_");
return ((parts[0] === subject.corner)
? parts.slice(1).join("_")
: null);
}
/**
* @author fenris
*/
function has(subject, key) {
return localStorage.hasOwnProperty(compose_full_key(subject, key));
}
/**
* @author fenris
*/
function clear(subject) {
(Object.keys(localStorage)
.map(function (x) { return decompose_full_key(subject, x); })
.filter(function (x) { return (x !== null); })
.forEach(function (x) { return localStorage.removeItem(x); }));
}
localstorage.clear = clear;
/**
* @author fenris
*/
function write(subject, key, item) {
var exists = has(subject, key);
localStorage.setItem(compose_full_key(subject, key), item);
return exists;
}
localstorage.write = write;
/**
* @author fenris
*/
function delete_(subject, key) {
localStorage.removeItem(compose_full_key(subject, key));
}
localstorage.delete_ = delete_;
/**
* @author fenris
*/
function read(subject, key) {
var full_key = compose_full_key(subject, key);
if (!localStorage.hasOwnProperty(full_key)) {
throw (new Error("not found"));
}
else {
return localStorage.getItem(full_key);
}
}
localstorage.read = read;
/**
* @author fenris
*/
function list(subject) {
return (Object.keys(localStorage)
.map(function (x) { return decompose_full_key(subject, x); })
.filter(function (x) { return (x !== null); }));
}
localstorage.list = list;
/**
*/
function implementation_chest(parameters) {
function wrap(core) {
return (new Promise(function (resolve, reject) { resolve(core()); }));
}
var subject = make(parameters);
return {
"setup": function (input) { return Promise.resolve(undefined); },
"clear": function () { return wrap(function () { return clear(subject); }); },
"write": function (key, item) { return wrap(function () { return write(subject, key, item); }); },
"delete": function (key) { return wrap(function () { return delete_(subject, key); }); },
"read": function (key) { return wrap(function () { return read(subject, key); }); },
"search": function (term) { return Promise.resolve(list(subject)
.map(function (key) { return ({ "key": key, "preview": key }); })); }
};
}
localstorage.implementation_chest = implementation_chest;
})(localstorage = storage.localstorage || (storage.localstorage = {}));
})(storage = lib_plankton.storage || (lib_plankton.storage = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:storage«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:storage« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:storage« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:storage«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var storage;
(function (storage) {
var localstorage;
(function (localstorage) {
/**
* uses the browsers localstorage as chest
*
* @author fenris
*/
var class_chest = /** @class */ (function () {
function class_chest(parameters) {
this.subject = localstorage.make(parameters);
}
class_chest.prototype.setup = function (input) { return Promise.resolve(undefined); };
class_chest.prototype.clear = function () { return Promise.resolve(localstorage.clear(this.subject)); };
class_chest.prototype.write = function (key, value) { return Promise.resolve(localstorage.write(this.subject, key, value)); };
class_chest.prototype["delete"] = function (key) { return Promise.resolve(localstorage.delete_(this.subject, key)); };
class_chest.prototype.read = function (key) { return Promise.resolve(localstorage.read(this.subject, key)); };
class_chest.prototype.search = function (term) {
return Promise.resolve(localstorage.list(this.subject)
.map(function (key) { return ({ "key": key, "preview": key }); }));
};
return class_chest;
}());
localstorage.class_chest = class_chest;
})(localstorage = storage.localstorage || (storage.localstorage = {}));
})(storage = lib_plankton.storage || (lib_plankton.storage = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:map«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:map« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:map« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:map«. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file is part of »bacterio-plankton:map«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:map« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:map« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:map«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var map;
(function (map_1) {
/**
*/
function clear(map) {
map.iterate(function (value, key) {
map["delete"](key);
});
}
map_1.clear = clear;
/**
*/
function keys(map) {
var keys = [];
map.iterate(function (value, key) {
keys.push(key);
});
return keys;
}
map_1.keys = keys;
/**
*/
function values(map) {
var values = [];
map.iterate(function (value, key) {
values.push(value);
});
return values;
}
map_1.values = values;
/**
*/
function dump(map) {
var pairs = [];
map.iterate(function (value, key) {
pairs.push({ "key": key, "value": value });
});
return pairs;
}
map_1.dump = dump;
/**
*/
function show(map, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"show_key": instance_show,
"show_value": instance_show
}, options);
return ("["
+
(dump(map)
.map(function (_a) {
var key = _a["key"], value = _a["value"];
return (options.show_key(key)
+
" -> "
+
options.show_value(value));
})
.join(", "))
+
"]");
}
map_1.show = show;
})(map = lib_plankton.map || (lib_plankton.map = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:map«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:map« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:map« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:map«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var map;
(function (map) {
var simplemap;
(function (simplemap) {
/**
*/
function make(options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"data": {}
}, options);
return {
"data": options.data
};
}
simplemap.make = make;
/**
*/
function size(subject) {
return Object.keys(subject.data).length;
}
simplemap.size = size;
/**
*/
function has(subject, key) {
return (key in subject.data);
}
simplemap.has = has;
/**
*/
function get_safe(subject, key) {
if (key in subject.data) {
return lib_plankton.pod.make_filled(subject.data[key]);
}
else {
return lib_plankton.pod.make_empty();
}
}
simplemap.get_safe = get_safe;
/**
*/
function get(subject, key, fallback) {
if (fallback === void 0) { fallback = lib_plankton.pod.make_empty(); }
if (key in subject.data) {
return subject.data[key];
}
else {
if (!lib_plankton.pod.is_filled(fallback)) {
throw (new Error("key not found"));
}
else {
return lib_plankton.pod.cull(fallback);
}
}
}
simplemap.get = get;
/**
*/
function set(subject, key, value) {
subject.data[key] = value;
}
simplemap.set = set;
/**
*/
function delete_(subject, key) {
delete subject.data[key];
}
simplemap.delete_ = delete_;
/**
*/
function iterate(subject, procedure) {
Object.entries(subject.data).forEach(function (_a) {
var key = _a[0], value = _a[1];
procedure(value, key);
});
}
simplemap.iterate = iterate;
/**
*/
function implementation_map(subject) {
return {
"size": function () { return size(subject); },
"has": function (key) { return has(subject, key); },
"get": function (key, fallback) { return get(subject, key, fallback); },
"set": function (key, value) { return set(subject, key, value); },
"delete": function (key) { return delete_(subject, key); },
"iterate": function (function_) { return iterate(subject, function_); }
};
}
simplemap.implementation_map = implementation_map;
})(simplemap = map.simplemap || (map.simplemap = {}));
})(map = lib_plankton.map || (lib_plankton.map = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:map«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:map« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:map« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:map«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var map;
(function (map) {
var hashmap;
(function (hashmap) {
/**
*/
function make(hashing, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"pairs": []
}, options);
var subject = {
"hashing": hashing,
"core": lib_plankton.map.simplemap.make({})
};
options.pairs.forEach(function (pair) {
set(subject, pair.key, pair.value);
});
return subject;
}
hashmap.make = make;
/**
*/
function size(subject) {
return lib_plankton.map.simplemap.size(subject.core);
}
hashmap.size = size;
/**
*/
function has(subject, key) {
return lib_plankton.map.simplemap.has(subject.core, subject.hashing(key));
}
hashmap.has = has;
/**
*/
function get(subject, key, fallback) {
if (fallback === void 0) { fallback = lib_plankton.pod.make_empty(); }
/*
we have to adjust the fallback argument, so that it can be used in our underlying simplemap core
therefore we pack the value together with any key as dummy
*/
return (lib_plankton.map.simplemap.get(subject.core, subject.hashing(key), lib_plankton.pod.propagate(fallback, function (value) { return ({
"key": key,
"value": value
}); }))
.value);
}
hashmap.get = get;
/**
*/
function set(subject, key, value) {
var key_ = subject.hashing(key);
return (lib_plankton.map.simplemap.set(subject.core, key_, { "key": key, "value": value }));
}
hashmap.set = set;
/**
*/
function delete_(subject, key) {
return (lib_plankton.map.simplemap.delete_(subject.core, subject.hashing(key)));
}
hashmap.delete_ = delete_;
/**
*/
function iterate(subject, procedure) {
return (lib_plankton.map.simplemap.iterate(subject.core, function (_a, key_) {
var key = _a["key"], value = _a["value"];
procedure(value, key);
}));
}
hashmap.iterate = iterate;
/**
*/
function implementation_map(subject) {
return {
"size": function () { return size(subject); },
"has": function (key) { return has(subject, key); },
"get": function (key, fallback) { return get(subject, key, fallback); },
"set": function (key, value) { return set(subject, key, value); },
"delete": function (key) { return delete_(subject, key); },
"iterate": function (procedure) { return iterate(subject, procedure); }
};
}
hashmap.implementation_map = implementation_map;
})(hashmap = map.hashmap || (map.hashmap = {}));
})(map = lib_plankton.map || (lib_plankton.map = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:map«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:map« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:map« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
3GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:map«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var map;
(function (map) {
var collatemap;
(function (collatemap) {
/**
*/
function make(collation, options) {
if (options === void 0) { options = {}; }
options = Object.assign({
"pairs": []
}, options);
var subject = {
"collation": collation,
"pairs": []
};
options.pairs.forEach(function (pair) {
set(subject, pair.key, pair.value);
});
return subject;
}
collatemap.make = make;
/**
*/
function size(subject) {
return subject.pairs.length;
}
collatemap.size = size;
/**
*/
function has(subject, key) {
return (subject.pairs.some(function (pair) { return subject.collation(key, pair.key); }));
}
collatemap.has = has;
/**
* @todo use .find
*/
function get(subject, key, fallback) {
var value;
var found = (subject.pairs
.some(function (pair) {
if (subject.collation(key, pair.key)) {
value = pair.value;
return true;
}
else {
return false;
}
}));
if (found) {
return value;
}
else {
if (!lib_plankton.pod.is_filled(fallback)) {
throw (new Error("key not found"));
}
else {
return lib_plankton.pod.cull(fallback);
}
}
}
collatemap.get = get;
/**
*/
function set(subject, key, value) {
var found = (subject.pairs
.some(function (pair) {
if (subject.collation(key, pair.key)) {
// pair.value = value;
return true;
}
else {
return false;
}
}));
if (found) {
// nothing
}
else {
subject.pairs.push({
"key": key,
"value": value
});
}
}
collatemap.set = set;
/**
*/
function delete_(subject, key) {
var index;
var found = (subject.pairs
.some(function (pair, index_) {
if (subject.collation(key, pair.key)) {
index = index_;
return true;
}
else {
return false;
}
}));
if (found) {
subject.pairs.splice(index, 1);
}
else {
// do nothing
}
}
collatemap.delete_ = delete_;
/**
*/
function iterate(subject, function_) {
subject.pairs
.forEach(function (pair) {
function_(pair.value, pair.key);
});
}
collatemap.iterate = iterate;
/**
*/
function implementation_map(subject) {
return {
"size": function () { return size(subject); },
"has": function (key) { return has(subject, key); },
"get": function (key, fallback) { return get(subject, key, fallback); },
"set": function (key, value) { return set(subject, key, value); },
"delete": function (key) { return delete_(subject, key); },
"iterate": function (function_) { return iterate(subject, function_); }
};
}
collatemap.implementation_map = implementation_map;
})(collatemap = map.collatemap || (map.collatemap = {}));
})(map = lib_plankton.map || (lib_plankton.map = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:pit«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:pit« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:pit« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:pit«. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file is part of »bacterio-plankton:pit«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:pit« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:pit« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:pit«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var pit;
(function (pit_1) {
/**
* @todo complete
*/
function timezone_name_to_timezone_shift(timezone_name) {
const map = {
"UTC": 0,
"CET": +1,
"CEST": +2,
};
if (!(timezone_name in map)) {
throw (new Error("unhandled timezone: " + timezone_name));
}
else {
return map[timezone_name];
}
}
pit_1.timezone_name_to_timezone_shift = timezone_name_to_timezone_shift;
/**
*/
function date_object_get_week_of_year(date) {
let date_ = new Date(date.getTime());
date_.setHours(0, 0, 0, 0);
// Thursday in current week decides the year.
date_.setDate(date_.getDate() + 3 - (date_.getDay() + 6) % 7);
// January 4 is always in week 1.
let week1 = new Date(date_.getFullYear(), 0, 4);
// Adjust to Thursday in week 1 and count number of weeks from date to week1.
return (1
+
Math.round((((date_.getTime() - week1.getTime()) / 86400000)
-
3
+
(week1.getDay() + 6) % 7)
/
7));
}
pit_1.date_object_get_week_of_year = date_object_get_week_of_year;
/**
*/
function to_unix_timestamp(pit) {
return pit;
}
pit_1.to_unix_timestamp = to_unix_timestamp;
/**
*/
function from_unix_timestamp(unix_timestamp) {
return unix_timestamp;
}
pit_1.from_unix_timestamp = from_unix_timestamp;
/**
*/
function to_date_object(pit) {
return (new Date(pit * 1000));
}
pit_1.to_date_object = to_date_object;
/**
*/
function from_date_object(date_object) {
return Math.round(date_object.getTime() / 1000);
}
/**
* @todo test
*/
function to_datetime(pit, { "timezone_shift": option_timezone_shift = 0, } = {}) {
return lib_plankton.call.convey(pit, [
to_date_object,
(x) => x.getTime(),
(x) => (x + ((option_timezone_shift * (60 * 60)) * 1000)),
(x) => new Date(x),
x => x.toISOString(),
x => ({
"timezone_shift": option_timezone_shift,
"date": {
"year": parseInt(x.slice(0, 4)),
"month": parseInt(x.slice(5, 7)),
"day": parseInt(x.slice(8, 10)),
},
"time": {
"hour": parseInt(x.slice(11, 13)),
"minute": parseInt(x.slice(14, 16)),
"second": parseInt(x.slice(17, 19)),
},
})
]);
}
pit_1.to_datetime = to_datetime;
/**
*/
function from_datetime(datetime) {
return lib_plankton.call.convey(datetime, [
(x) => lib_plankton.string.coin("{{year}}-{{month}}-{{day}}T{{hour}}:{{minute}}:{{second}}.000+{{shift}}", {
"year": x.date.year.toFixed(0).padStart(4, "0"),
"month": x.date.month.toFixed(0).padStart(2, "0"),
"day": x.date.day.toFixed(0).padStart(2, "0"),
"hour": ((x.time !== null) ? x.time.hour : 0).toFixed(0).padStart(2, "0"),
"minute": ((x.time !== null) ? x.time.minute : 0).toFixed(0).padStart(2, "0"),
"second": ((x.time !== null) ? x.time.second : 0).toFixed(0).padStart(2, "0"),
"shift": (x.timezone_shift.toFixed(0).padStart(2, "0") + ":00"),
}),
x => (new Date(x)),
from_date_object,
]);
}
pit_1.from_datetime = from_datetime;
/**
*/
function is_before(pit, reference) {
return (pit < reference);
}
pit_1.is_before = is_before;
/**
*/
function is_after(pit, reference) {
return (pit > reference);
}
/**
*/
function is_between(pit, reference_left, reference_right) {
return (is_after(pit, reference_left)
&&
is_before(pit, reference_right));
}
pit_1.is_between = is_between;
/**
*/
function shift_hour(pit, increment) {
return (pit + (60 * 60 * increment));
}
/**
*/
function shift_day(pit, increment) {
return (pit + (60 * 60 * 24 * increment));
}
pit_1.shift_day = shift_day;
/**
*/
function shift_week(pit, increment) {
return (pit + (60 * 60 * 24 * 7 * increment));
}
pit_1.shift_week = shift_week;
/**
*/
function shift_year(pit, increment) {
return (pit + (60 * 60 * 24 * 365 * increment));
}
/**
*/
function trunc_minute(pit) {
const datetime_input = to_datetime(pit);
const datetime_output = {
"timezone_shift": 0,
"date": {
"year": datetime_input.date.year,
"month": datetime_input.date.month,
"day": datetime_input.date.day,
},
"time": {
"hour": ((datetime_input.time === null)
?
0
:
datetime_input.time.hour),
"minute": ((datetime_input.time === null)
?
0
:
datetime_input.time.minute),
"second": 0,
},
};
return from_datetime(datetime_output);
}
/**
*/
function trunc_hour(pit) {
const datetime_input = to_datetime(pit);
const datetime_output = {
"timezone_shift": 0,
"date": {
"year": datetime_input.date.year,
"month": datetime_input.date.month,
"day": datetime_input.date.day,
},
"time": {
"hour": ((datetime_input.time === null)
?
0
:
datetime_input.time.hour),
"minute": 0,
"second": 0,
},
};
return from_datetime(datetime_output);
}
/**
*/
function trunc_day(pit) {
const datetime_input = to_datetime(pit);
const datetime_output = {
"timezone_shift": 0,
"date": {
"year": datetime_input.date.year,
"month": datetime_input.date.month,
"day": datetime_input.date.day,
},
"time": {
"hour": 0,
"minute": 0,
"second": 0,
},
};
return from_datetime(datetime_output);
}
/**
*/
function trunc_week(pit) {
const date_object = to_date_object(pit);
return lib_plankton.call.convey(date_object.getDay(), [
(x) => ((x === 0) ? 7 : x),
(x) => (x - 1),
(x) => shift_day(pit, (-x)),
trunc_day
]);
}
pit_1.trunc_week = trunc_week;
/**
*/
function trunc_month(pit) {
const datetime_input = to_datetime(pit);
const datetime_output = {
"timezone_shift": 0,
"date": {
"year": datetime_input.date.year,
"month": datetime_input.date.month,
"day": 1,
},
"time": {
"hour": 0,
"minute": 0,
"second": 0,
},
};
return from_datetime(datetime_output);
}
/**
*/
function trunc_year(pit) {
const datetime_input = to_datetime(pit);
const datetime_output = {
"timezone_shift": 0,
"date": {
"year": datetime_input.date.year,
"month": 1,
"day": 1,
},
"time": {
"hour": 0,
"minute": 0,
"second": 0,
},
};
return from_datetime(datetime_output);
}
/**
*/
function now() {
return from_date_object(new Date(Date.now()));
}
pit_1.now = now;
/**
* @param year year according to specified timezone shift
* @param week week according to specified timezone shift
* @return the begin of the week (monday, 00:00)
*/
function from_ywd(ywd, { "timezone_shift": option_timezone_shift = 0, } = {}) {
return lib_plankton.call.convey({
"timezone_shift": option_timezone_shift,
"date": {
"year": ywd.year,
"month": 1,
"day": 1,
},
"time": {
"hour": 0,
"minute": 0,
"second": 0
}
}, [
from_datetime,
(x) => shift_week(x, (ywd.week - 1)),
trunc_week,
(x) => shift_day(x, (ywd.day - 1)),
]);
}
pit_1.from_ywd = from_ywd;
/**
* @todo timezone
*/
function to_ywd(pit, { "timezone_shift": option_timezone_shift = 0, } = {}) {
return lib_plankton.call.convey(pit, [
to_date_object,
x => ({
"year": x.getFullYear(),
"week": date_object_get_week_of_year(x),
"day": ((day => (day <= 0) ? 7 : day)(x.getDay())),
})
]);
}
pit_1.to_ywd = to_ywd;
/**
* computes the point in time for switching to central european summer time
*
* @todo write tests
*/
function cest_switch_on(year) {
return lib_plankton.call.convey(year, [
(x) => ({
"timezone_shift": 0,
"date": {
"year": x,
"month": 4,
"day": 1,
},
"time": {
"hour": 2,
"minute": 0,
"second": 0
},
}),
from_datetime,
trunc_week,
x => shift_day(x, -1),
]);
}
pit_1.cest_switch_on = cest_switch_on;
/**
* computes the point in time for switching away from central european summer time
*
* @todo write tests
*/
function cest_switch_off(year) {
return lib_plankton.call.convey(year, [
(x) => ({
"timezone_shift": 0,
"date": {
"year": x,
"month": 11,
"day": 1,
},
"time": {
"hour": 1,
"minute": 0,
"second": 0
},
}),
from_datetime,
trunc_week,
x => shift_day(x, -1),
]);
}
pit_1.cest_switch_off = cest_switch_off;
/**
*/
function timezone_shift_ce(pit) {
const year = to_datetime(pit).date.year;
return (is_between(pit, cest_switch_on(year), cest_switch_off(year))
? +2
: +1);
}
pit_1.timezone_shift_ce = timezone_shift_ce;
/**
* [convenience]
*/
function to_datetime_ce(pit) {
return to_datetime(pit, {
"timezone_shift": timezone_shift_ce(pit),
});
}
pit_1.to_datetime_ce = to_datetime_ce;
/**
*/
function datetime_translate(datetime, timezone_shift) {
if (datetime.timezone_shift === timezone_shift) {
return datetime;
}
else {
const pit = from_datetime(datetime);
const pit_shifted = shift_hour(pit, (timezone_shift - datetime.timezone_shift));
const datetime_shifted = to_datetime(pit_shifted);
return {
"timezone_shift": timezone_shift,
"date": datetime_shifted.date,
"time": ((datetime.time === null)
?
null
: datetime_shifted.time)
};
}
}
pit_1.datetime_translate = datetime_translate;
/**
* [convenience]
*/
function datetime_translate_ce(datetime) {
return datetime_translate(datetime, timezone_shift_ce(from_datetime(datetime)));
}
pit_1.datetime_translate_ce = datetime_translate_ce;
/**
*/
function timezone_shift_format(timezone_shift) {
return lib_plankton.string.coin("{{sign}}{{value}}", {
"sign": ((timezone_shift === 0)
?
" "
:
((timezone_shift > 0)
?
"+"
:
"-")),
"value": Math.abs(timezone_shift).toFixed(0),
});
}
pit_1.timezone_shift_format = timezone_shift_format;
/**
*/
function date_format(date) {
return lib_plankton.string.coin("{{year}}-{{month}}-{{day}}", {
"year": date.year.toFixed(0).padStart(4, "0"),
"month": date.month.toFixed(0).padStart(2, "0"),
"day": date.day.toFixed(0).padStart(2, "0"),
});
}
pit_1.date_format = date_format;
/**
*/
function time_format(time, { "show_seconds": option_show_seconds = false, } = {}) {
return lib_plankton.string.coin((option_show_seconds
?
"{{hour}}:{{minute}}:{{seconds}}"
:
"{{hour}}:{{minute}}"), {
"hour": time.hour.toFixed(0).padStart(2, "0"),
"minute": time.minute.toFixed(0).padStart(2, "0"),
"second": time.second.toFixed(0).padStart(2, "0"),
});
}
pit_1.time_format = time_format;
/**
* @todo show timezone
*/
function datetime_format(datetime, { "timezone_indicator": option_timezone_indicator = "", "show_timezone": option_show_timezone = false, "adjust_to_ce": option_adjust_to_ce = false, "omit_date": option_omit_date = false, } = {}) {
if (datetime === null) {
return "-";
}
else {
const datetime_adjusted = (option_adjust_to_ce
?
to_datetime_ce(from_datetime(datetime))
:
datetime);
return lib_plankton.string.coin("{{macro_date_and_time}}{{macro_timezone}}", {
"macro_date_and_time": ([
// date
(option_omit_date
?
null
:
date_format(datetime_adjusted.date)),
// time
((datetime_adjusted.time === null)
?
null
:
time_format(datetime_adjusted.time)),
]
.filter(x => (x !== null))
.join(", ")),
"macro_timezone": (option_show_timezone
?
lib_plankton.string.coin(" [{{timezone_indicator}}{{timezone_value}}]", {
"timezone_indicator": option_timezone_indicator,
"timezone_value": timezone_shift_format(datetime_adjusted.timezone_shift),
})
:
""),
});
}
}
pit_1.datetime_format = datetime_format;
/**
*/
function timespan_format(from, to, { "timezone_indicator": option_timezone_indicator = "", "show_timezone": option_show_timezone = false, "adjust_to_ce": option_adjust_to_ce = false, "omit_date": option_omit_date = false, } = {}) {
const from_adjusted = (option_adjust_to_ce
?
datetime_translate_ce(from)
:
from);
const to_adjusted = ((to === null)
?
null
:
(option_adjust_to_ce
?
datetime_translate_ce(to)
:
to));
return lib_plankton.string.coin("{{from}}{{to_macro}}{{macro_timezone}}", {
"from": datetime_format(from_adjusted, {
"show_timezone": false,
"adjust_to_ce": false,
"omit_date": option_omit_date,
}),
"to_macro": ((to_adjusted === null)
?
""
:
lib_plankton.string.coin(" - {{to}}", {
"to": datetime_format(to_adjusted, {
"omit_date": ((from_adjusted.date.year === to_adjusted.date.year)
&&
(from_adjusted.date.month === to_adjusted.date.month)
&&
(from_adjusted.date.day === to_adjusted.date.day))
}),
})),
"macro_timezone": (option_show_timezone
?
lib_plankton.string.coin(" [{{timezone_indicator}}{{timezone_value}}]", {
"timezone_indicator": option_timezone_indicator,
"timezone_value": timezone_shift_format(from_adjusted.timezone_shift),
})
:
""),
});
}
pit_1.timespan_format = timespan_format;
})(pit = lib_plankton.pit || (lib_plankton.pit = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_wrapped {
/**
*/
constructor(core, wrap, unwrap, options = {}) {
options = Object.assign({}, options);
this.core = core;
this.wrap = wrap;
this.unwrap = unwrap;
}
/**
* [implementation]
*/
setup(parent) {
return this.core.setup(parent);
}
/**
* [implementation]
*/
read() {
return (this.core.read()
.then(value_inner => Promise.resolve(this.wrap(value_inner))));
}
/**
* [implementation]
*/
write(value) {
return this.core.write(this.unwrap(value));
}
}
zoo_input.class_input_wrapped = class_input_wrapped;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_soft {
/**
*/
constructor(core, options = {}) {
options = Object.assign({}, options);
this.core = core;
this.dom_set = null;
this.dom_wrapper = null;
}
/**
*/
toggle(also_element, mode) {
if (also_element) {
this.dom_set.checked = mode;
}
else {
// do nothing
}
this.dom_wrapper.classList.toggle("plankton_input_soft_inactive", (!mode));
}
/**
* [implementation]
*/
async setup(parent) {
let dom_container = document.createElement("div");
dom_container.classList.add("plankton_input_soft_container");
{
// set
{
this.dom_set = document.createElement("input");
this.dom_set.setAttribute("type", "checkbox");
this.dom_set.classList.add("plankton_input_soft_setter");
dom_container.appendChild(this.dom_set);
}
// core
{
this.dom_wrapper = document.createElement("div");
this.dom_wrapper.classList.add("plankton_input_soft_core_wrapper");
dom_container.appendChild(this.dom_wrapper);
await this.core.setup(this.dom_wrapper);
}
}
this.dom_set.addEventListener("change", (event) => {
this.toggle(false, event.target.checked);
});
parent.appendChild(dom_container);
this.toggle(true, false);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
if (!this.dom_set.checked) {
return Promise.resolve(null);
}
else {
return this.core.read();
}
}
/**
* [implementation]
*/
write(value) {
if (value === null) {
this.toggle(true, false);
return Promise.resolve(undefined);
}
else {
this.toggle(true, true);
return this.core.write(value);
}
}
}
zoo_input.class_input_soft = class_input_soft;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_hidden {
/**
*/
constructor(options = {}) {
options = Object.assign({
"initial_value": null,
}, options);
this.dom_input = null;
this.value = options.initial_value;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "hidden");
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.value);
}
/**
* [implementation]
*/
write(value) {
this.value = value;
return Promise.resolve(undefined);
}
}
zoo_input.class_input_hidden = class_input_hidden;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
* @todo abstract
*/
class class_input_text {
/**
*/
constructor(options = {}) {
options = Object.assign({
"read_only": false,
"pattern": null,
// "autocompletion_list": null,
}, options);
this.read_only = options.read_only;
this.pattern = options.pattern;
// this.autocompletion_list = options.autocompletion_list;
this.dom_input = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "text");
{
if (!this.read_only) {
// do nothing
}
else {
this.dom_input.setAttribute("disabled", "disabled");
}
}
{
if (this.pattern === null) {
// do nothing
}
else {
this.dom_input.setAttribute("pattern", this.pattern);
}
}
{
/*
if (this.autocompletion_list === null) {
// do nothing
}
else {
const autocomplete : class_autocomplete = new class_autocomplete(
this.dom_input,
this.autocompletion_list
);
autocomplete.init();
}
*/
}
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.dom_input.value);
}
/**
* [implementation]
*/
write(value) {
this.dom_input.value = value;
return Promise.resolve(undefined);
}
}
zoo_input.class_input_text = class_input_text;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_email {
/**
*/
constructor() {
this.dom_input = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "email");
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.dom_input.value);
}
/**
* [implementation]
*/
write(value) {
this.dom_input.value = value;
return Promise.resolve(undefined);
}
}
zoo_input.class_input_email = class_input_email;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_textarea {
/**
*/
constructor() {
this.dom_textarea = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_textarea = document.createElement("textarea");
parent.appendChild(this.dom_textarea);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.dom_textarea.value);
}
/**
* [implementation]
*/
write(value) {
this.dom_textarea.value = value;
return Promise.resolve(undefined);
}
}
zoo_input.class_input_textarea = class_input_textarea;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
*/
function value_decode(datestring) {
const parts = datestring.split("-");
return {
"year": parseInt(parts[0]),
"month": parseInt(parts[1]),
"day": parseInt(parts[2]),
};
}
/**
*/
function value_encode(date) {
return lib_plankton.string.coin("{{year}}-{{month}}-{{day}}", {
"year": date.year.toFixed(0).padStart(4, "0"),
"month": date.month.toFixed(0).padStart(2, "0"),
"day": date.day.toFixed(0).padStart(2, "0"),
});
}
/**
* @author fenris
*/
class class_input_date {
/**
*/
constructor(options = {}) {
options = Object.assign({
"required": false,
}, options);
this.required = options.required;
this.dom_input = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "date");
if (!this.required) {
// do nothing
}
else {
this.dom_input.setAttribute("required", "required");
}
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
if (this.required && (!this.dom_input.reportValidity())) {
return Promise.reject("required");
}
else {
return Promise.resolve((this.dom_input.value === "")
? null
: value_decode(this.dom_input.value));
}
}
/**
* [implementation]
*/
write(value) {
this.dom_input.value = ((value === null)
? ""
: value_encode(value));
return Promise.resolve(undefined);
}
}
zoo_input.class_input_date = class_input_date;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
* @todo abstract
*/
class class_input_number {
/**
*/
constructor(options = {}) {
options = Object.assign({
"read_only": false,
"step": null,
}, options);
this.read_only = options.read_only;
this.step = options.step;
this.dom_input = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "number");
// readonly
{
if (!this.read_only) {
// do nothing
}
else {
this.dom_input.setAttribute("disabled", "disabled");
}
}
// step
{
if (this.step === null) {
// do nothing
}
else {
this.dom_input.setAttribute("step", this.step.toString());
}
}
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(Number(this.dom_input.value));
}
/**
* [implementation]
*/
write(value) {
this.dom_input.value = value.toString();
return Promise.resolve(undefined);
}
}
zoo_input.class_input_number = class_input_number;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_checkbox {
/**
*/
constructor(options = {}) {
options = Object.assign({
"read_only": false,
"hooks_change": [],
}, options);
this.read_only = options.read_only;
this.dom_input = null;
this.hooks_change = options.hooks_change;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "checkbox");
{
if (this.read_only) {
this.dom_input.setAttribute("disabled", "disabled");
}
else {
// do nothing
}
}
this.dom_input.addEventListener("change", (event) => {
const value = event.target.checked;
this.hooks_change.forEach(procedure => {
procedure(value);
});
});
// this.dom_input.style.display = "initial"; // n3o!!!
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.dom_input.checked);
}
/**
* [implementation]
*/
write(value) {
this.dom_input.checked = value;
return Promise.resolve(undefined);
}
}
zoo_input.class_input_checkbox = class_input_checkbox;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_selection {
/**
*/
constructor(options) {
this.options = options;
this.dom_select = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_select = document.createElement("select");
this.options.forEach((option) => {
let dom_option = document.createElement("option");
dom_option.setAttribute("value", option.value);
dom_option.textContent = option.label;
this.dom_select.appendChild(dom_option);
});
parent.appendChild(this.dom_select);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.dom_select.value);
}
/**
* [implementation]
*/
write(value) {
this.dom_select.value = value;
return Promise.resolve(undefined);
}
}
zoo_input.class_input_selection = class_input_selection;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_enumeration {
/**
*/
constructor(options) {
this.options = options;
this.dom_inputs = [];
}
/**
* [implementation]
* @todo unique name
*/
setup(parent) {
let dom_container = document.createElement("div");
dom_container.classList.add("plankton_input_enumeration");
const name = "radio";
this.options.forEach((option) => {
let dom_label = document.createElement("label");
let dom_input = document.createElement("input");
dom_input.setAttribute("type", "radio");
dom_input.setAttribute("name", name);
dom_input.setAttribute("value", option.value);
dom_label.appendChild(dom_input);
let dom_span = document.createElement("span");
dom_span.textContent = option.label;
dom_label.appendChild(dom_span);
dom_container.appendChild(dom_label);
this.dom_inputs.push(dom_input);
});
parent.appendChild(dom_container);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
const active = (this.dom_inputs
.filter(dom_input => dom_input.checked)
.map(dom_input => dom_input.value));
if (active.length != 1) {
return Promise.reject("nothing picked");
}
else {
return Promise.resolve(active[0]);
}
}
/**
* [implementation]
*/
write(value) {
this.dom_inputs.forEach(dom_input => {
dom_input.checked = (value === dom_input.value);
});
return Promise.resolve(undefined);
}
}
zoo_input.class_input_enumeration = class_input_enumeration;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_list {
/**
*/
constructor(element_input_factory, options = {}) {
options = Object.assign({
"read_only": false,
"translations": {
"add": "add",
"remove": "remove",
},
}, options);
this.element_input_factory = element_input_factory;
this.elements = [];
this.elements_container_dom = null;
this.read_only = options.read_only;
this.translations = options.translations;
}
/**
*/
clear() {
this.elements_container_dom.innerHTML = "";
this.elements = [];
return Promise.resolve(undefined);
}
/**
*/
async add() {
// model
let element_dom = document.createElement("div");
const input = this.element_input_factory();
this.elements.push({ "dom": element_dom, "input": input });
// view & control
{
element_dom.classList.add("plankton_input_list_element");
// remover
{
let remover_dom = document.createElement("button");
remover_dom.classList.add("plankton_input_list_button");
remover_dom.classList.add("plankton_input_list_element_remover");
remover_dom.setAttribute("title", this.translations.remove);
if (this.read_only) {
remover_dom.setAttribute("disabled", "disabled");
}
remover_dom.textContent = "x";
remover_dom.addEventListener("click", (event) => {
event.preventDefault();
const index = this.elements.findIndex(element => (element.input === input));
const element = this.elements[index];
this.elements_container_dom.removeChild(element.dom);
this.elements.splice(index, 1);
});
element_dom.appendChild(remover_dom);
}
// input
{
let input_dom = document.createElement("div");
input_dom.classList.add("plankton_input_list_element_input");
await input.setup(input_dom);
element_dom.appendChild(input_dom);
}
this.elements_container_dom.appendChild(element_dom);
}
return Promise.resolve(input);
}
/**
* [implementation]
*/
setup(parent) {
let container_dom = document.createElement("div");
container_dom.classList.add("plankton_input_list");
// elements
{
this.elements_container_dom = document.createElement("div");
this.elements_container_dom.classList.add("plankton_input_list_elements");
container_dom.appendChild(this.elements_container_dom);
}
// foot
{
let footer_dom = document.createElement("div");
footer_dom.classList.add("plankton_input_list_foot");
// adder
{
let adder_dom = document.createElement("button");
adder_dom.classList.add("plankton_input_list_button");
adder_dom.classList.add("plankton_input_list_adder");
adder_dom.setAttribute("title", this.translations.add);
if (this.read_only) {
adder_dom.setAttribute("disabled", "disabled");
}
adder_dom.textContent = "+";
adder_dom.addEventListener("click", (event) => {
event.preventDefault();
this.add();
});
footer_dom.appendChild(adder_dom);
}
container_dom.appendChild(footer_dom);
}
parent.appendChild(container_dom);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return (Promise.all(this.elements
.map((element, index) => (element.input.read()
.then((element_value) => Promise.resolve({
"index": index,
"value": element_value,
})))))
.then((elements) => Promise.resolve(elements
.sort((x, y) => ((x.index <= y.index) ? 0 : 1))
.map(element => element.value))));
}
/**
* [implementation]
*/
write(value) {
return (this.clear()
.then(() => Promise.all(value
.map((element_value) => (this.add()
.then(element_input => element_input.write(element_value))))))
.then(() => Promise.resolve(undefined)));
}
}
zoo_input.class_input_list = class_input_list;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_password {
/**
*/
constructor() {
this.dom_input = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "password");
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.dom_input.value);
}
/**
* [implementation]
*/
write(value) {
this.dom_input.value = value;
return Promise.resolve(undefined);
}
}
zoo_input.class_input_password = class_input_password;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_switch {
/**
*/
constructor() {
this.dom_element = null;
this.value = false;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_element = document.createElement("input");
this.dom_element.setAttribute("type", "text");
this.dom_element.setAttribute("readonly", "readonly");
this.dom_element.addEventListener("click", (event) => {
this.write(!this.value);
});
parent.appendChild(this.dom_element);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve(this.value);
}
/**
* [implementation]
*/
write(value) {
this.value = value;
if (value) {
this.dom_element.value = "✔";
}
else {
this.dom_element.value = " ";
}
return Promise.resolve(undefined);
}
}
zoo_input.class_input_switch = class_input_switch;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
*/
function value_encode(time) {
return lib_plankton.string.coin("{{hour}}:{{minute}}", {
"hour": time.hour.toFixed(0).padStart(2, "0"),
"minute": time.minute.toFixed(0).padStart(2, "0"),
});
}
/**
*/
function value_decode(timestring) {
const parts = timestring.split(":");
return {
"hour": parseInt(parts[0]),
"minute": parseInt(parts[1]),
"second": 0,
};
}
/**
* @author fenris
*/
class class_input_time {
/**
*/
constructor() {
this.dom_input = null;
}
/**
* [implementation]
*/
setup(parent) {
this.dom_input = document.createElement("input");
this.dom_input.setAttribute("type", "time");
parent.appendChild(this.dom_input);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
read() {
return Promise.resolve((this.dom_input.value === "")
? null
: value_decode(this.dom_input.value));
}
/**
* [implementation]
*/
write(value) {
this.dom_input.value = ((value === null)
? ""
: value_encode(value));
return Promise.resolve(undefined);
}
}
zoo_input.class_input_time = class_input_time;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* @author fenris
*/
class class_input_group {
/**
*/
constructor(fields_raw) {
this.fields = (fields_raw
.map(field_raw => ({
"name": field_raw.name,
"input": field_raw.input,
"label": (field_raw.label ?? null),
"help": (field_raw.help ?? null),
})));
}
/**
* [implementation]
*/
async setup(parent) {
let dom_group = document.createElement("div");
dom_group.classList.add("plankton_input_group");
for await (const field of this.fields) {
let dom_field = document.createElement("div");
dom_field.classList.add("plankton_input_group_field");
dom_field.setAttribute("rel", field.name);
await Promise.all([
// label
new Promise((resolve, reject) => {
if (field.label === null) {
// do nothing
}
else {
let dom_label = document.createElement("label");
dom_label.classList.add("plankton_input_group_field_label");
dom_label.textContent = field.label;
dom_field.appendChild(dom_label);
}
resolve(undefined);
}),
// help
new Promise((resolve, reject) => {
if (field.help === null) {
// do nothing
}
else {
let dom_help = document.createElement("span");
dom_help.classList.add("plankton_input_group_field_help");
dom_help.textContent = "(?)";
dom_help.setAttribute("title", field.help);
dom_field.appendChild(dom_help);
}
resolve(undefined);
}),
// input
field.input.setup(dom_field),
]);
dom_group.appendChild(dom_field);
// return Promise.resolve<void>(undefined);
}
parent.appendChild(dom_group);
return Promise.resolve(undefined);
}
/**
* [implementation]
*/
async read() {
return (Promise.all(this.fields.map((field) => (field.input.read()
.then((value) => Promise.resolve({ "key": field.name, "value": value })))))
.then(pairs => Promise.resolve(Object.fromEntries(pairs.map((pair) => ([pair.key, pair.value]))))));
}
/**
* [implementation]
*/
write(value) {
return (Promise.resolve(Object.entries(value).map(([key, value]) => ({ "key": key, "value": value })))
.then((pairs) => Promise.all(pairs.map((pair) => (Promise.all(this.fields.filter((field) => (field.name === pair.key))
.map((field) => field.input.write(pair.value)))
.then(() => Promise.resolve(undefined))))))
.then(() => Promise.resolve(undefined)));
}
}
zoo_input.class_input_group = class_input_group;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
*/
class class_input_hashmap {
/**
*/
constructor(hash_key, key_input_factory, value_input_factory) {
this.hash_key = hash_key;
this.core = new lib_plankton.zoo_input.class_input_list(() => new lib_plankton.zoo_input.class_input_group([
{
"name": "key",
"input": key_input_factory(),
},
{
"name": "value",
"input": value_input_factory(),
},
]));
}
/**
* [implementation]
*/
setup(parent) {
return this.core.setup(parent);
}
/**
* [implementation]
*/
async read() {
const pairs = await this.core.read();
const map = lib_plankton.map.hashmap.implementation_map(lib_plankton.map.hashmap.make(this.hash_key, {
"pairs": pairs
}));
return Promise.resolve(map);
}
/**
* [implementation]
*/
async write(map) {
const pairs = lib_plankton.map.dump(map);
await this.core.write(pairs);
return Promise.resolve(undefined);
}
}
zoo_input.class_input_hashmap = class_input_hashmap;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
*/
class class_input_datetime {
/**
*/
constructor(options = {}) {
options = Object.assign({
"label_timezone_shift": "",
"label_date": "",
"label_time": "",
}, options);
this.core = new zoo_input.class_input_group([
{
"name": "timezone_shift",
"input": new zoo_input.class_input_number(),
"label": options.label_timezone_shift,
},
{
"name": "date",
"input": new zoo_input.class_input_date(),
"label": options.label_date,
},
{
"name": "time",
"input": new zoo_input.class_input_soft(new zoo_input.class_input_time()),
"label": options.label_time,
},
]);
}
/**
*/
setup(parent) {
return this.core.setup(parent);
}
/**
*/
read() {
return this.core.read();
}
/**
*/
write(value) {
return this.core.write(value);
}
}
zoo_input.class_input_datetime = class_input_datetime;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-input«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-input« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-input« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-input«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_input;
(function (zoo_input) {
/**
* for central europe with daylight saving time feature
*/
class class_input_datetime_central_europe {
/**
*/
constructor(options = {}) {
options = Object.assign({
"label_date": "",
"label_time": "",
}, options);
this.core = new zoo_input.class_input_group([
{
"name": "date",
"input": new zoo_input.class_input_date(),
"label": options.label_date,
},
{
"name": "time",
"input": new zoo_input.class_input_soft(new zoo_input.class_input_time()),
"label": options.label_time,
},
]);
}
/**
*/
setup(parent) {
return this.core.setup(parent);
}
/**
*/
async read() {
const datetime_easy = await this.core.read();
const datetime_cet = {
"timezone_shift": 1,
"date": datetime_easy.date,
"time": datetime_easy.time,
};
const datetime_cest = {
"timezone_shift": 2,
"date": datetime_easy.date,
"time": datetime_easy.time,
};
const datetime = (lib_plankton.pit.is_between(lib_plankton.pit.from_datetime(datetime_cet), lib_plankton.pit.cest_switch_on(datetime_easy.date.year), lib_plankton.pit.cest_switch_off(datetime_easy.date.year))
?
datetime_cest
:
datetime_cet);
if (datetime_easy.time === null) {
datetime.time = null;
}
else {
// do nothing
}
return Promise.resolve(datetime);
}
/**
*/
async write(value) {
const pit = lib_plankton.pit.from_datetime(value);
const datetime_utc = lib_plankton.pit.to_datetime(pit, {
"timezone_shift": 0,
});
const datetime_relative = lib_plankton.pit.to_datetime(pit, {
"timezone_shift": (lib_plankton.pit.is_between(lib_plankton.pit.from_datetime(datetime_utc), lib_plankton.pit.cest_switch_on(datetime_utc.date.year), lib_plankton.pit.cest_switch_off(datetime_utc.date.year))
?
2
:
1)
});
const datetime_easy = {
"date": datetime_relative.date,
"time": ((value.time === null) ? null : datetime_relative.time),
};
return this.core.write(datetime_easy);
}
}
zoo_input.class_input_datetime_central_europe = class_input_datetime_central_europe;
})(zoo_input = lib_plankton.zoo_input || (lib_plankton.zoo_input = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-form«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-form« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-form« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-form«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_form;
(function (zoo_form) {
/**
*/
function make(method, fields, encode, decode, options = {}) {
options = Object.assign({
"class_prefix": "plankton_form_",
}, options);
return {
"method": method,
"fields": fields.map(field_raw => ({
"name": field_raw.name,
"type": field_raw.type,
"label": (field_raw.label ?? null),
})),
"encode": encode,
"decode": decode,
"class_prefix": options.class_prefix,
"root_element": null,
};
}
zoo_form.make = make;
/**
*/
function make_simple(method, fields, options = {}) {
options = Object.assign({
"class_prefix": "plankton_form_",
}, options);
return {
"method": method,
"fields": fields.map(field_raw => ({
"name": field_raw.name,
"type": field_raw.type,
"label": (field_raw.label ?? null),
})),
"encode": x => x,
"decode": x => x,
"class_prefix": options.class_prefix,
"root_element": null,
};
}
zoo_form.make_simple = make_simple;
/**
*/
function class_name(subject, name) {
return lib_plankton.string.coin("{{class_prefix}}{{name}}", {
"class_prefix": subject.class_prefix,
"name": name,
});
}
/**
*/
function field_input(subject, field) {
return subject.root_element.querySelector(lib_plankton.string.coin(".{{class}}[name=\"{{name}}\"]", {
"class": class_name(subject, "input"),
"name": field.name,
}));
}
/**
*/
function clear(subject) {
subject.fields.forEach(field => {
switch (field.type) {
default: {
field_input(subject, field).value = "";
break;
}
case "checkbox": {
field_input(subject, field).checked = false;
break;
}
}
});
}
zoo_form.clear = clear;
/**
*/
function write(subject, value) {
let raw = subject.encode(value);
subject.fields.forEach(field => {
switch (field.type) {
default: {
field_input(subject, field).value = raw[field.name];
break;
}
case "checkbox": {
field_input(subject, field).checked = (raw[field.name] === "on");
break;
}
}
});
}
zoo_form.write = write;
/**
*/
function read(subject) {
let raw = {};
subject.fields.forEach(field => {
switch (field.type) {
default: {
raw[field.name] = field_input(subject, field).value;
break;
}
case "checkbox": {
raw[field.name] = (field_input(subject, field).checked ? "on" : "off");
break;
}
}
});
const value = subject.decode(raw);
return value;
}
zoo_form.read = read;
/**
*/
async function render(subject, target) {
let element_form = document.createElement("form");
element_form.classList.add(class_name(subject, "form"));
subject.fields.forEach(field => {
let element_field = document.createElement("div");
element_field.classList.add(class_name(subject, "field"));
// label
{
let element_label = document.createElement("label");
element_label.classList.add(class_name(subject, "label"));
element_field.appendChild(element_label);
element_label.textContent = (field.label
??
field.name.split("_").join(" "));
}
// input
{
let element_input = document.createElement("input");
element_input.classList.add(class_name(subject, "input"));
element_input.setAttribute("name", field.name);
element_input.setAttribute("type", field.type);
element_field.appendChild(element_input);
}
element_form.appendChild(element_field);
});
subject.root_element = element_form;
target.appendChild(element_form);
return Promise.resolve(undefined);
}
zoo_form.render = render;
})(zoo_form = lib_plankton.zoo_form || (lib_plankton.zoo_form = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-form«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-form« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-form« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-form«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_form;
(function (zoo_form) {
/**
* @author fenris
*/
class class_form {
/**
*/
constructor(encode, decode, input, actions) {
this.encode = encode;
this.decode = decode;
this.input = input;
this.actions = actions;
}
/**
*/
async setup(parent) {
let dom_form = document.createElement("form");
dom_form.classList.add("plankton_form");
// input
{
let dom_container = document.createElement("div");
dom_container.classList.add("plankton_form_input");
await this.input.setup(dom_container);
dom_form.appendChild(dom_container);
}
// actions
{
let dom_container = document.createElement("div");
dom_container.classList.add("plankton_form_actions");
this.actions.forEach((action) => {
let dom_button = document.createElement("button");
// dom_button.setAttribute("type", "submit");
dom_button.textContent = action.label;
if (action.target !== undefined) {
dom_button.setAttribute("formaction", action.target);
}
if (action.procedure !== undefined) {
dom_button.addEventListener("click", (event) => {
event.preventDefault();
action.procedure(() => this.input_read(), () => this.input_read_raw());
});
}
dom_container.appendChild(dom_button);
});
dom_form.appendChild(dom_container);
}
parent.appendChild(dom_form);
}
/**
*/
input_read_raw() {
return this.input.read();
}
/**
*/
async input_read() {
return this.decode(await this.input.read());
}
/**
*/
input_write(value) {
return this.input.write(this.encode(value));
}
}
zoo_form.class_form = class_form;
})(zoo_form = lib_plankton.zoo_form || (lib_plankton.zoo_form = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-search«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-search« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-search« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-search«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_search;
(function (zoo_search) {
/**
*/
function class_name(subject, name) {
return lib_plankton.string.coin("{{class_prefix}}{{name}}", {
"class_prefix": subject.class_prefix,
"name": name,
});
}
/**
*/
function make(routine, options) {
options = Object.assign({
"encode_item": (item) => JSON.stringify(item),
"hooks_select": [],
"hooks_begin": [],
"hooks_end": [],
"class_prefix": "plankton_search_",
}, options);
return {
"routine": routine,
"encode_item": options.encode_item,
"hooks_select": options.hooks_select,
"hooks_begin": options.hooks_begin,
"hooks_end": options.hooks_end,
"class_prefix": options.class_prefix,
"root_element": null,
"state": null,
};
}
zoo_search.make = make;
/**
*/
function hook_begin(subject, action) {
subject.hooks_begin.push(action);
}
zoo_search.hook_begin = hook_begin;
/**
*/
function hook_end(subject, action) {
subject.hooks_end.push(action);
}
zoo_search.hook_end = hook_end;
/**
*/
function hook_select(subject, action) {
subject.hooks_select.push(action);
}
zoo_search.hook_select = hook_select;
/**
*/
function clear(subject) {
// term
{
let term_element = subject.root_element.querySelector("." + class_name(subject, "input"));
term_element.value = "";
}
// list
{
let list_element = subject.root_element.querySelector("." + class_name(subject, "hits"));
list_element.innerHTML = "";
}
return Promise.resolve(undefined);
}
/**
*/
async function fill(subject, term) {
subject.hooks_begin.forEach(action => { action(term); });
// term
{
let term_element = subject.root_element.querySelector("." + class_name(subject, "input"));
term_element.setAttribute("placeholder", "search");
term_element.value = term;
}
// list
{
let list_element = subject.root_element.querySelector("." + class_name(subject, "hits"));
list_element.innerHTML = "searching …";
const hits = await subject.routine(term);
list_element.innerHTML = "";
hits.forEach(item => {
let item_element = document.createElement("li");
item_element.classList.add(class_name(subject, "item"));
item_element.textContent = subject.encode_item(item);
item_element.addEventListener("click", () => {
subject.hooks_select.forEach(action => { action(item); });
});
list_element.appendChild(item_element);
});
}
// external
{
subject.hooks_end.forEach(action => { action(); });
}
return Promise.resolve(undefined);
}
/**
*/
async function set_state(subject, state) {
if ((subject.state !== null)
&&
(state.term === subject.state.term)) {
// do nothing
}
else {
subject.state = state;
if (state.term === null) {
await clear(subject);
}
else {
await fill(subject, state.term);
}
}
return Promise.resolve(undefined);
}
zoo_search.set_state = set_state;
/**
*/
async function render(subject, target, options = {}) {
options = Object.assign({
"state": { "term": null },
}, options);
let container_element = document.createElement("div");
container_element.classList.add(class_name(subject, "search"));
// form
{
let form_element = document.createElement("form");
// term
{
let term_element = document.createElement("input");
term_element.setAttribute("type", "search");
term_element.setAttribute("name", "term");
term_element.classList.add(class_name(subject, "input"));
form_element.appendChild(term_element);
}
// submit
{
let submit_element = document.createElement("input");
submit_element.setAttribute("type", "submit");
submit_element.classList.add(class_name(subject, "submit"));
form_element.appendChild(submit_element);
}
form_element.addEventListener("submit", (event) => {
event.preventDefault();
const form_data = new FormData(form_element);
const term = form_data.get("term");
set_state(subject, { "term": term });
});
container_element.appendChild(form_element);
}
// hits
{
let hits_element = document.createElement("ul");
hits_element.classList.add(class_name(subject, "hits"));
container_element.appendChild(hits_element);
}
subject.root_element = container_element;
target.appendChild(container_element);
await set_state(subject, options.state);
return Promise.resolve(undefined);
}
zoo_search.render = render;
})(zoo_search = lib_plankton.zoo_search || (lib_plankton.zoo_search = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-editor«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-editor« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-editor« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-editor«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_editor;
(function (zoo_editor) {
/**
*/
let enum_mode;
(function (enum_mode) {
enum_mode["find"] = "find";
enum_mode["view"] = "view";
enum_mode["make"] = "make";
})(enum_mode = zoo_editor.enum_mode || (zoo_editor.enum_mode = {}));
;
/**
*/
let enum_action;
(function (enum_action) {
enum_action["keep"] = "keep";
enum_action["save"] = "save";
enum_action["delete"] = "delete";
enum_action["find"] = "find";
enum_action["make"] = "make";
})(enum_action = zoo_editor.enum_action || (zoo_editor.enum_action = {}));
;
/**
*/
let enum_function;
(function (enum_function) {
enum_function["seek"] = "seek";
enum_function["read"] = "read";
enum_function["create"] = "create";
enum_function["update"] = "update";
enum_function["delete"] = "delete";
})(enum_function = zoo_editor.enum_function || (zoo_editor.enum_function = {}));
;
/**
*/
function make(store, form, options = {}) {
options = Object.assign({
"functions": [
enum_function.seek,
enum_function.read,
enum_function.create,
enum_function.update,
enum_function.delete,
],
"encode_hit": (hit) => lib_plankton.string.coin("[{{key}}] {{preview}}", {
"key": JSON.stringify(hit.key),
"preview": JSON.stringify(hit.preview),
}),
"hook_switch": null,
"class_prefix": "plankton_editor_",
}, options);
return {
"functions": options.functions,
"store": store,
/*
// wrap store in order to restrict access according to allowed functions
"store": new RestrictedStorage(
store,
ArrayListHelper::map(
$this->functions,
function (string $function): string {return self::$actionMap[$function];}
)
),
*/
"search": lib_plankton.zoo_search.make((term) => store.search(term), {
"encode_item": options.encode_hit,
}),
"form": form,
"hook_switch": options.hook_switch,
"state": null,
"class_prefix": options.class_prefix,
"root_element": null,
};
}
zoo_editor.make = make;
/**
*/
function class_name(subject, name) {
return lib_plankton.string.coin("{{class_prefix}}{{name}}", {
"class_prefix": subject.class_prefix,
"name": name,
});
}
/**
*/
function map_function_to_store_action(function_) {
switch (function_) {
case enum_function.seek: return "seek";
case enum_function.read: return "read";
case enum_function.create: return "create";
case enum_function.update: return "update";
case enum_function.delete: return "delete";
}
}
/**
*/
function map_mode_to_functions(mode) {
switch (mode) {
case enum_mode.find: return [enum_function.seek];
case enum_mode.view: return [enum_function.read];
case enum_mode.make: return [enum_function.create];
}
}
/**
*/
function map_mode_to_actions(mode) {
switch (mode) {
case enum_mode.find: return [enum_action.make];
case enum_mode.view: return [enum_action.save, enum_action.delete, enum_action.find, enum_action.make];
case enum_mode.make: return [enum_action.keep, enum_action.find];
}
}
/**
*/
function map_action_to_class_body(action) {
return ("action_" + action);
}
/**
*/
function wait(subject, mode) {
subject.root_element.classList.toggle("waiting", mode);
// loader
{
// view
{
subject.root_element.querySelector("." + class_name(subject, "loader")).style.display = (mode ? "" : "none");
}
}
/*
// search
{
// view
{
(
subject.root_element.querySelector(
"." + class_name<type_key, type_value>(subject, "search")
) as HTMLElement
).style.display = ((! mode) ? "" : "none");
}
}
// form
{
// view
{
(
subject.root_element.querySelector(
"." + class_name<type_key, type_value>(subject, "form")
) as HTMLElement
).style.display = ((! mode) ? "" : "none");
}
}
// actions
{
// view
{
(
subject.root_element.querySelector(
"." + class_name<type_key, type_value>(subject, "actions")
) as HTMLElement
).style.display = ((! mode) ? "" : "none");
}
}
*/
}
/**
*/
async function set_state(subject, state) {
const state_old = subject.state;
subject.state = state;
// container
{
if (state_old === null) {
// do nothing
}
else {
subject.root_element.classList.remove(state_old.mode);
}
subject.root_element.classList.add(state.mode);
}
// search
{
// model
{
await lib_plankton.zoo_search.set_state(subject.search, state.search_state);
}
// view
{
subject.root_element.querySelector("." + class_name(subject, "search")).style.display = ([enum_mode.find].includes(state.mode)
? ""
: "none");
}
}
// form
{
// model
{
if (state.key === null) {
lib_plankton.zoo_form.clear(subject.form);
}
else {
lib_plankton.zoo_form.write(subject.form, await subject.store.read(state.key));
}
}
// view
{
subject.root_element.querySelector("." + class_name(subject, "form")).style.display = ([enum_mode.view, enum_mode.make].includes(state.mode)
? ""
: "none");
}
}
// actions
{
// view
{
[
enum_action.keep,
enum_action.save,
enum_action.delete,
enum_action.find,
enum_action.make,
]
.forEach(action => {
subject.root_element.querySelector("." + class_name(subject, map_action_to_class_body(action))).style.visibility = (map_mode_to_actions(state.mode).includes(action)
? ""
: "hidden");
});
}
}
// external
{
if (subject.hook_switch === null) {
// do nothing
}
else {
subject.hook_switch(state);
}
}
}
/**
*/
async function render(subject, target, options = {}) {
options = Object.assign({
"state": {
"mode": enum_mode.find,
"key": null,
"search_state": { "term": null },
},
}, options);
subject.state = options.state;
const element_all = document.createElement("div");
element_all.classList.add(class_name(subject, "container"));
{
// loader
{
const container_element = document.createElement("div");
container_element.classList.add(class_name(subject, "loader"));
// text
{
const text_element = document.createElement("div");
text_element.textContent = "…";
container_element.appendChild(text_element);
}
element_all.appendChild(container_element);
}
// search
{
const container_element = document.createElement("div");
container_element.classList.add(class_name(subject, "search"));
// search core
{
lib_plankton.zoo_search.hook_select(subject.search, async (hit) => {
wait(subject, true);
await set_state(subject, {
"mode": enum_mode.view,
"key": hit.key,
"search_state": { "term": null },
});
wait(subject, false);
});
lib_plankton.zoo_search.hook_begin(subject.search, (term) => {
set_state(subject, {
"mode": subject.state.mode,
"key": subject.state.key,
"search_state": { "term": term },
});
});
await lib_plankton.zoo_search.render(subject.search, container_element, {
"state": options.state.search_state,
});
}
element_all.appendChild(container_element);
}
// form
{
const container_element = document.createElement("div");
container_element.classList.add(class_name(subject, "form"));
// form core
{
await lib_plankton.zoo_form.render(subject.form, container_element);
}
element_all.appendChild(container_element);
}
// actions
{
let container_element = document.createElement("div");
container_element.classList.add(class_name(subject, "actions"));
{
[
{
"value": enum_action.find,
// TODO translate
"label": "search",
"procedure": async () => {
wait(subject, true);
set_state(subject, {
"mode": enum_mode.find,
"key": null,
"search_state": { "term": null },
});
wait(subject, false);
},
},
{
"value": enum_action.make,
// TODO translate
"label": "new",
"procedure": async () => {
wait(subject, true);
set_state(subject, {
"mode": enum_mode.make,
"key": null,
"search_state": { "term": null },
});
wait(subject, false);
},
},
{
"value": enum_action.keep,
// TODO translate
"label": "save",
"procedure": async () => {
wait(subject, true);
const value = lib_plankton.zoo_form.read(subject.form);
const key = await subject.store.create(value);
set_state(subject, {
"mode": enum_mode.view,
"key": key,
"search_state": { "term": null },
});
wait(subject, false);
},
},
{
"value": enum_action.save,
// TODO translate
"label": "apply",
"procedure": async () => {
wait(subject, true);
const value = lib_plankton.zoo_form.read(subject.form);
await subject.store.update(subject.state.key, value);
/*
set_state<type_key, type_value>(
subject,
{
"mode": enum_mode.view,
"key": subject.state.key,
"search_state": {"term": null},
}
);
*/
wait(subject, false);
},
},
{
"value": enum_action.delete,
// TODO translate
"label": "delete",
"procedure": async () => {
if (confirm("sure?")) {
wait(subject, true);
await subject.store.delete(subject.state.key);
set_state(subject, {
"mode": enum_mode.find,
"key": null,
"search_state": { "term": null },
});
wait(subject, false);
}
else {
// no nothing
}
},
},
]
.forEach(action => {
let button_element = document.createElement("button");
button_element.classList.add(class_name(subject, "action"));
button_element.classList.add(class_name(subject, map_action_to_class_body(action.value)));
button_element.textContent = action.label;
button_element.addEventListener("click", () => {
action.procedure();
});
container_element.appendChild(button_element);
});
}
element_all.appendChild(container_element);
}
target.appendChild(element_all);
}
subject.root_element = element_all;
set_state(subject, options.state);
wait(subject, false);
}
zoo_editor.render = render;
})(zoo_editor = lib_plankton.zoo_editor || (lib_plankton.zoo_editor = {}));
})(lib_plankton || (lib_plankton = {}));
/*
This file is part of »bacterio-plankton:zoo-page«.
Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR'
<info@greenscale.de>
»bacterio-plankton:zoo-page« is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
»bacterio-plankton:zoo-page« is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public License
along with »bacterio-plankton:zoo-page«. If not, see <http://www.gnu.org/licenses/>.
*/
var lib_plankton;
(function (lib_plankton) {
var zoo_page;
(function (zoo_page) {
/**
*/
zoo_page._pool = {};
/**
*/
let _fallback = null;
/**
*/
let _current = null;
/**
*/
let _target_element = null;
/**
*/
function encode(location) {
return ("#"
+
([location.name]
.concat(Object.entries(location.parameters)
.filter(([key, value]) => (value !== null))
.map(([key, value]) => (key + "=" + value)))));
}
zoo_page.encode = encode;
/**
*/
function decode(encoded) {
if (encoded === "") {
return null;
}
else {
if (!encoded.startsWith("#")) {
return null;
}
else {
const parts = encoded.slice(1).split(",");
return {
"name": parts[0],
"parameters": Object.fromEntries(parts.slice(1)
.map(part => {
const parts_ = part.split("=");
return [parts_[0], parts_[1]];
})),
};
}
}
}
/**
* renders a page to the main element
*/
async function load(location) {
// _target_element.innerHTML = "[loading …]";
_target_element.innerHTML = "";
if (location === null) {
// do nothing
}
else {
if (!(location.name in zoo_page._pool)) {
_target_element.innerHTML = "not found";
}
else {
await zoo_page._pool[location.name](location.parameters, _target_element);
_current = location;
}
}
}
/**
*/
function add_nav_entry(location, options = {}) {
options = Object.assign({
"label": null,
}, options);
let ul_element = document.querySelector("nav > ul");
{
let li_element = document.createElement("li");
{
let a_element = document.createElement("a");
a_element.setAttribute("href", encode(location));
a_element.textContent = (options.label ?? location.name);
li_element.appendChild(a_element);
}
ul_element.appendChild(li_element);
}
}
zoo_page.add_nav_entry = add_nav_entry;
/**
* retrieves the location from the set URL
*/
function get() {
return decode(window.location.hash);
}
/**
* encodes a location in the URL and loads it
*/
function set(location) {
window.location.hash = encode(location);
}
zoo_page.set = set;
/**
*/
function register(location_name, handler, options = {}) {
options = Object.assign({}, options);
zoo_page._pool[location_name] = handler;
}
zoo_page.register = register;
/**
*/
function init(target_element, options = {}) {
options = Object.assign({
"pool": {},
"fallback": null,
}, options);
_target_element = target_element;
_fallback = options.fallback;
Object.entries(options.pool).forEach(([location_name, handler]) => {
register(location_name, handler);
});
window.addEventListener("hashchange", () => {
const location_old = _current;
const location_new = (get() ?? _fallback);
if (((location_old === null)
&&
(location_new !== null))
||
((location_old !== null)
&&
(location_new !== null)
&&
(location_old.name !== location_new.name))) {
load(location_new);
}
else {
// do nothing
}
});
}
zoo_page.init = init;
/**
*/
function start() {
const location = (get() ?? _fallback);
set(location);
load(location);
}
zoo_page.start = start;
})(zoo_page = lib_plankton.zoo_page || (lib_plankton.zoo_page = {}));
})(lib_plankton || (lib_plankton = {}));
Reference in a new issue View git blame Copy permalink