From bfed93cf9e8d0710675b658ed578afe0b8b394b8 Mon Sep 17 00:00:00 2001 From: Fenris Wolf Date: Fri, 6 Mar 2026 08:41:27 +0100 Subject: [PATCH] [ini] --- .gitignore | 3 + doc/brock.schema.json | 60 + doc/examples/contacts.sindri.json | 66 + doc/examples/sweets.sindri.json | 13 + doc/sindri.schema.json | 129 + lib/plankton/plankton.d.ts | 1880 +++++ lib/plankton/plankton.js | 6668 +++++++++++++++++ readme.md | 94 + source/base.ts | 127 + source/conf.ts | 189 + source/main.ts | 135 + source/outputs/backend/typescript/logic.ts | 339 + .../backend/typescript/templates/api.ts.tpl | 118 + .../typescript/templates/entity.ts.tpl | 4 + .../typescript/templates/master.ts.tpl | 74 + .../typescript/templates/repository.ts.tpl | 113 + source/outputs/database/mysql/logic.ts | 221 + source/outputs/database/postgresql/logic.ts | 255 + source/outputs/database/sqlite/logic.ts | 183 + source/outputs/frontend/typescript/logic.ts | 37 + .../frontend/typescript/templates/core.ts.tpl | 251 + source/outputs/other/jsonschema/logic.ts | 103 + todo.md | 3 + tools/build | 4 + tools/clear | 3 + tools/get-plankton | 15 + tools/install | 3 + tools/makefile | 44 + tools/place-templates | 17 + 29 files changed, 11151 insertions(+) create mode 100644 .gitignore create mode 100644 doc/brock.schema.json create mode 100644 doc/examples/contacts.sindri.json create mode 100644 doc/examples/sweets.sindri.json create mode 100644 doc/sindri.schema.json create mode 100644 lib/plankton/plankton.d.ts create mode 100644 lib/plankton/plankton.js create mode 100644 readme.md create mode 100644 source/base.ts create mode 100644 source/conf.ts create mode 100644 source/main.ts create mode 100644 source/outputs/backend/typescript/logic.ts create mode 100644 source/outputs/backend/typescript/templates/api.ts.tpl create mode 100644 source/outputs/backend/typescript/templates/entity.ts.tpl create mode 100644 source/outputs/backend/typescript/templates/master.ts.tpl create mode 100644 source/outputs/backend/typescript/templates/repository.ts.tpl create mode 100644 source/outputs/database/mysql/logic.ts create mode 100644 source/outputs/database/postgresql/logic.ts create mode 100644 source/outputs/database/sqlite/logic.ts create mode 100644 source/outputs/frontend/typescript/logic.ts create mode 100644 source/outputs/frontend/typescript/templates/core.ts.tpl create mode 100644 source/outputs/other/jsonschema/logic.ts create mode 100644 todo.md create mode 100755 tools/build create mode 100755 tools/clear create mode 100755 tools/get-plankton create mode 100755 tools/install create mode 100644 tools/makefile create mode 100755 tools/place-templates diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..05e8b11 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +temp/ +build/ +.geany diff --git a/doc/brock.schema.json b/doc/brock.schema.json new file mode 100644 index 0000000..3dd9e3c --- /dev/null +++ b/doc/brock.schema.json @@ -0,0 +1,60 @@ +{ + "type": "object", + "properties": { + "database": { + "type": "object", + "properties": { + "kind": { + "type": "string" + }, + "data": { + "type": "object", + "properties": { + }, + "additionalProperties": { + }, + "required": [ + ] + } + }, + "additionalProperties": false, + "required": [ + "kind" + ] + }, + "backend": { + "type": "object", + "properties": { + "schema": { + "type": "string", + "enum": ["http", "https"] + }, + "host": { + "type": "string" + }, + "port": { + "type": "integer" + } + }, + "additionalProperties": false, + "required": [ + "schema", + "host", + "port" + ] + }, + "frontend": { + "type": "object", + "properties": { + }, + "additionalProperties": false, + "required": [ + ] + } + }, + "required": [ + "database", + "backend", + "frontend" + ] +} diff --git a/doc/examples/contacts.sindri.json b/doc/examples/contacts.sindri.json new file mode 100644 index 0000000..d7b96e3 --- /dev/null +++ b/doc/examples/contacts.sindri.json @@ -0,0 +1,66 @@ +{ + "domains": [ + { + "name": "address", + "description": "collection of addresses", + "key_field": { + "name": "id" + }, + "data_fields": [ + { + "name": "city", + "description": "the name of the city", + "nullable": false, + "type": "string_medium" + }, + { + "name": "zip", + "description": "the postal code", + "nullable": false, + "type": "string_medium" + }, + { + "name": "street", + "description": "the name of the street and the house number", + "nullable": false, + "type": "string_medium" + + } + ] + }, + { + "name": "person", + "description": "collection of contacts", + "key_field": { + "name": "id" + }, + "data_fields": [ + { + "name": "prename", + "description": "first name of the person", + "nullable": false, + "type": "string_medium" + }, + { + "name": "surname", + "description": "last name of the person", + "nullable": false, + "type": "string_medium" + }, + { + "name": "address_id", + "description": "reference to the associated address dataset", + "nullable": false, + "type": "integer" + }, + { + "name": "email_address", + "description": "optional eMail address", + "nullable": true, + "type": "string_medium", + "default": null + } + ] + } + ] +} diff --git a/doc/examples/sweets.sindri.json b/doc/examples/sweets.sindri.json new file mode 100644 index 0000000..62afa1d --- /dev/null +++ b/doc/examples/sweets.sindri.json @@ -0,0 +1,13 @@ +{ + "domains": [ + { + "name": "sweets", + "description": "collection of sweets", + "key_field": {"name": "id"}, + "data_fields": [ + {"name": "name", "type": "string_medium"}, + {"name": "calories", "type": "integer"} + ] + } + ] +} diff --git a/doc/sindri.schema.json b/doc/sindri.schema.json new file mode 100644 index 0000000..08f529d --- /dev/null +++ b/doc/sindri.schema.json @@ -0,0 +1,129 @@ +{ + "type": "object", + "additionalProperties": false, + "properties": { + "domains": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": [ + "null", + "string" + ], + "default": null + }, + "key_field": { + "type": [ + "null", + "object" + ], + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": [ + "null", + "string" + ], + "default": null + } + }, + "required": [ + "name" + ], + "default": null + }, + "data_fields": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": [ + "null", + "string" + ], + "default": null + }, + "type": { + "type": "string", + "enum": [ + "boolean", + "integer", + "float", + "string_short", + "string_medium", + "string_long" + ] + }, + "nullable": { + "type": "boolean", + "default": true + }, + "default": { + "type": [ + "null", + "boolean", + "integer", + "float", + "string" + ], + "default": null + } + }, + "required": [ + "name", + "type" + ] + }, + "default": [] + }, + "constraints": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": false, + "properties": { + "kind": { + "type": "string", + "enum": [ + "unique", + "foreign_key" + ] + }, + "parameters": { + "type": "object", + "additionalProperties": "string", + "properties": {}, + "required": [] + } + }, + "required": [ + "kind" + ] + }, + "default": [] + } + }, + "required": [ + "name" + ] + } + } + }, + "required": [ + "domains" + ] +} diff --git a/lib/plankton/plankton.d.ts b/lib/plankton/plankton.d.ts new file mode 100644 index 0000000..20f1256 --- /dev/null +++ b/lib/plankton/plankton.d.ts @@ -0,0 +1,1880 @@ +/** + * @author fenris + */ +type int = number; +/** + * @author fenris + */ +type float = number; +declare var process: any; +declare var require: any; +declare class Buffer { + constructor(x: string, modifier?: string); + static from(x: string, encoding?: string): any; + toString(modifier?: string): string; +} +declare namespace lib_plankton.base { + /** + * @author fenris + */ + function environment(): string; +} +/** + * @author fenris + */ +type type_pseudopointer = { + value: type_value; +}; +/** + * @author fenris + */ +declare function pseudopointer_null(): type_pseudopointer; +/** + * @author fenris + */ +declare function pseudopointer_make(value: type_value): type_pseudopointer; +/** + * @author fenris + */ +declare function pseudopointer_isset(pseudopointer: type_pseudopointer): boolean; +/** + * @author fenris + */ +declare function pseudopointer_read(pseudopointer: type_pseudopointer): type_value; +/** + * @author fenris + */ +declare function pseudopointer_write(pseudopointer: type_pseudopointer, value: type_value): void; +/** + * @author fenris + */ +declare var instance_verbosity: int; +/** + * @desc the ability to check for equality with another element of the same domain + * @author fenris + */ +interface interface_collatable { + /** + * @author fenris + */ + _collate(value: type_value): boolean; +} +/** + * @author fenris + */ +declare function instance_collate(value1: (type_value & { + _collate?: ((value: type_value) => boolean); +}), value2: type_value): boolean; +/** + * @desc the ability to compare with another element of the same domain for determining if the first is "smaller than or equal to" the latter + * @author fenris + */ +interface interface_comparable { + /** + * @author fenris + */ + _compare(value: type_value): boolean; +} +/** + * @author fenris + */ +declare function instance_compare(value1: (type_value & { + _compare: ((value: type_value) => boolean); +}), value2: type_value): boolean; +/** + * @desc the ability to create an exact copy + * @author fenris + */ +interface interface_cloneable { + /** + * @author fenris + */ + _clone(): type_value; +} +/** + * @author fenris + */ +declare function instance_clone(value: (type_value & { + _clone?: (() => type_value); +})): type_value; +/** + * @author fenris + */ +interface interface_hashable { + /** + * @author fenris + */ + _hash(): string; +} +/** + * @desc the ability to generate a string out of the element, which identifies it to a high degree + * @author fenris + */ +declare function instance_hash(value: (type_value & { + _hash?: (() => string); +})): string; +/** + * @author fenris + */ +interface interface_showable { + /** + * @author fenris + */ + _show(): string; +} +/** + * @desc the ability to map the element to a textual representation (most likely not injective) + * @author fenris + */ +declare function instance_show(value: (type_value & { + _show?: (() => string); +})): string; +/** + * @author frac + */ +interface interface_decorator { + /** + * @author frac + */ + core: type_core; +} +/** + * @author frac + */ +declare class class_observer { + /** + * @author frac + */ + protected counter: int; + /** + * @author frac + */ + protected actions: { + [id: string]: (information: Object) => void; + }; + /** + * @author frac + */ + protected buffer: Array; + /** + * @author frac + */ + constructor(); + /** + * @author frac + */ + empty(): boolean; + /** + * @author frac + */ + flush(): void; + /** + * @author frac + */ + set(id: string, action: (information: Object) => void): void; + /** + * @author frac + */ + del(id: string): void; + /** + * @author frac + */ + add(action: (information: Object) => void): void; + /** + * @author frac + */ + notify(information?: Object, delayed?: boolean): void; + /** + * @author frac + */ + rollout(): void; +} +/** + * @author frac + */ +/** + * @author frac + */ +/** + * @author frac + */ +declare class class_error extends Error { + /** + * @author frac + */ + protected suberrors: Array; + /** + * @author frac + */ + protected mess: string; + /** + * @author frac + */ + constructor(message: string, suberrors?: Array); + /** + * @override + * @author frac + */ + toString(): string; +} +declare namespace lib_plankton.base { + /** + * returns the current UNIX timestamp + * + * @author fenris + */ + function get_current_timestamp(rounded?: boolean): float; + /** + */ + function object_merge(core: Record, mantle: Record): Record; +} +declare namespace lib_plankton.email { + /** + */ + function send(smtp_credentials: { + host: string; + port: int; + username: string; + password: string; + }, sender: string, receivers: Array, subject: string, content: string): Promise; +} +declare namespace lib_plankton.log { + /** + */ + enum enum_level { + debug = 0, + info = 1, + notice = 2, + warning = 3, + error = 4 + } + /** + */ + function level_order(level1: enum_level, level2: enum_level): boolean; + /** + */ + function level_show(level: enum_level): string; + /** + */ + type type_entry = { + level: enum_level; + incident: string; + details: Record; + }; +} +/** + * @deprecated + * @todo remove + */ +declare namespace lib_plankton.log { + function level_push(level: int): void; + function level_pop(): void; + function indent_push(indent: int): void; + function indent_pop(): void; + function indent_inc(): void; + function indent_dec(): void; + /** + * @author fenris + */ + function write({ "message": message, "type": type, "prefix": prefix, "level": level, "indent": indent, }: { + message?: string; + type?: string; + prefix?: string; + level?: int; + indent?: int; + }): void; +} +declare namespace lib_plankton.log { + /** + */ + abstract class class_channel { + /** + */ + abstract add(entry: type_entry): void; + } +} +declare namespace lib_plankton.log { + /** + * output for writing log entries to stdout + */ + class class_channel_stdout extends class_channel { + /** + */ + add(entry: type_entry): void; + } +} +declare namespace lib_plankton.log { + /** + */ + class class_channel_file extends class_channel { + /** + * the path of the log file + */ + private path; + /** + */ + private human_readable; + /** + * [constructor] + */ + constructor(path: string, human_readable: boolean); + /** + */ + add(entry: type_entry): void; + } +} +declare namespace lib_plankton.log { + /** + */ + class class_channel_email extends class_channel { + /** + */ + private smtp_credentials; + /** + */ + private sender; + /** + */ + private receivers; + /** + * [constructor] + */ + constructor(smtp_credentials: { + host: string; + port: int; + username: string; + password: string; + }, sender: string, receivers: Array); + /** + */ + add(entry: type_entry): void; + } +} +declare namespace lib_plankton.log { + /** + * output for desktop notifications via "libnotify" + */ + class class_channel_notify extends class_channel { + /** + */ + add(entry: type_entry): void; + } +} +declare namespace lib_plankton.log { + /** + * decorator for filtering out log entries below a certain level threshold + */ + class class_channel_minlevel extends class_channel { + /** + */ + private core; + /** + */ + private threshold; + /** + */ + constructor(core: class_channel, threshold: enum_level); + /** + */ + add(entry: type_entry): void; + } +} +declare namespace lib_plankton.log { + /** + */ + function channel_make(description: { + kind: string; + data?: { + [key: string]: any; + }; + }): class_channel; + /** + */ + type type_configuration = Array; + /** + */ + function conf_default(): type_configuration; +} +declare namespace lib_plankton.log { + /** + * pushes a new configuration on the stack and activates it + */ + function conf_push(channels: type_configuration): void; + /** + * pops the current active configuration from the stack + */ + function conf_pop(): void; + /** + * consumes a log entry, i.e. sends it to the currently active outputs + */ + function add(entry: type_entry): void; + /** + */ + function debug(incident: string, details?: Record): void; + /** + */ + function info(incident: string, details?: Record): void; + /** + */ + function notice(incident: string, details?: Record): void; + /** + */ + function warning(incident: string, details?: Record): void; + /** + */ + function error(incident: string, details?: Record): void; +} +declare namespace lib_plankton.log { +} +declare var plain_text_to_html: (text: string) => string; +/** + * @desc makes a valid + */ +declare var format_sentence: (str: string, rtl?: boolean, caseSense?: boolean) => string; +declare var fill_string_template: (template_string: string, object: any, fabric: Function, delimiter: string, default_string: string, sloppy: boolean) => string; +declare var make_string_template: (_template: string, _fabrics?: Object) => (object: { + [key: string]: string; +}) => string; +declare var make_eml_header: (object: { + [key: string]: string; +}) => string; +declare var make_eml_body: Object; +declare namespace lib_plankton.string { + /** + * @author neuc,frac + */ + function empty(str: string): boolean; + /** + * @desc returns a unique string + * @param {string} prefix an optional prefix for the generated string + * @return {string} + * @author fenris + */ + function generate(prefix?: string): string; + /** + * @author fenris + */ + function join(parts: Array, glue?: string): string; + /** + * @desc splits a string, but returns an empty list, if the string is empty + * @param {string} chain + * @param {string} separator + * @return {Array} + * @author fenris + */ + function split(chain: string, separator?: string): Array; + /** + * @author neu3no + */ + function explode(str: string, needle: string, max: int): Array; + /** + * @desc concats a given word with itself n times + * @param {string} word + * @param {int} + * @return {string} + * @author fenris + */ + function repeat(word: string, count: int): string; + /** + * @desc lengthens a string by repeatedly appending or prepending another string + * @param {string} word the string to pad + * @param {int} length the length, which the result shall have + * @param {string} symbol the string, which will be added (multiple times) + * @param {boolean} [prepend]; whether to prepend (~true) or append (~false); default: false + * @return {string} the padded string + * @author fenris + */ + function pad(word: string, length: int, symbol?: string, mode?: string): string; + /** + * @desc checks if a given string conttains a certain substring + * @param {string} string + * @param {string} part + * @return {boolean} + * @author fenris + */ + function contains(chain: string, part: string): boolean; + /** + * @desc checks if a given string starts with a certain substring + * @param {string} string + * @param {string} part + * @return {boolean} + * @author fenris + */ + function startsWith(chain: string, part: string): boolean; + /** + * @desc checks if a given string ends with a certain substring + * @param {string} string + * @param {string} part + * @return {boolean} + * @author fenris + */ + function endsWith(chain: string, part: string): boolean; + /** + * @desc count the occourrences of a string in a string + * @param string haystack_string the string wich should be examined + * @param string needle_string the string which should be counted + * @author neuc + */ + function count_occourrences(haystack_string: string, needle_string: string, check_escape: boolean): int; + /** + * @author fenris + */ + function replace(str: string, replacements: Array<{ + from: string; + to: string; + }>, options?: {}): string; + /** + * @desc replaces occurences of "{{name}}" in a string by the corresponding values of an argument object + * @author fenris + */ + function coin(str: string, args: { + [id: string]: string; + }, options?: { + legacy?: boolean; + open?: string; + close?: string; + }): string; + /** + * @author fenris + * @deprecated use limit + */ + function cut(str: string, length: int, delimiter?: string): string; + /** + */ + function limit(str: string, options?: { + length?: int; + indicator?: string; + }): string; + /** + */ + function slice(str: string, size: int): Array; +} +/** + * @deprecated + */ +declare namespace lib_string { + const empty: typeof lib_plankton.string.empty; + const generate: typeof lib_plankton.string.generate; + const split: typeof lib_plankton.string.split; + const explode: typeof lib_plankton.string.repeat; + const repeat: typeof lib_plankton.string.repeat; + const pad: typeof lib_plankton.string.pad; + const contains: typeof lib_plankton.string.contains; + const startsWith: typeof lib_plankton.string.startsWith; + const endsWith: typeof lib_plankton.string.endsWith; + const count_occourrences: typeof lib_plankton.string.count_occourrences; + const coin: typeof lib_plankton.string.coin; + const stance: typeof lib_plankton.string.coin; + const cut: typeof lib_plankton.string.cut; +} +declare namespace lib_plankton.string { + /** + * an implementation of c sprintf + * @param {string} string format string + * @param {array} args arguments which should be filled into + * @returns {string} + */ + var sprintf: (input: string, args?: Array, original?: any) => string; + /** + * an implementation of c printf + * @param {string} string format string + * @param {array} args arguments which should be filled into + * @returns {string} + */ + function printf(format: any, args: any): void; +} +declare var sprintf: (input: string, args?: Array, original?: any) => string; +declare var printf: typeof lib_plankton.string.printf; +declare var eml_log: any; +declare var track_exports: any; +declare var make_logger: (prefix: any, current_loglevel: any) => (obj: any, lvl: any) => void; +declare namespace lib_plankton.code { + /** + * @author fenris + */ + interface interface_code { + /** + * @author fenris + */ + encode(x: type_from): type_to; + /** + * @author fenris + */ + decode(x: type_to): type_from; + } +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + type type_code = { + /** + * @author fenris + */ + encode: (x: type_from) => type_to; + /** + * @author fenris + */ + decode: (x: type_to) => type_from; + }; +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + function inverse_encode(decode: (to: type_to) => type_from, to: type_to): type_from; + /** + * @author fenris + */ + function inverse_decode(encode: (from: type_from) => type_to, from: type_from): type_to; +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + class class_code_inverse implements interface_code { + /** + * @author fenris + */ + protected subject: interface_code; + /** + * @author fenris + */ + constructor(subject: interface_code); + /** + * @implementation + * @author fenris + */ + encode(to: type_to): type_from; + /** + * @implementation + * @author fenris + */ + decode(from: type_from): type_to; + } +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + function pair_encode(encode_first: (from: type_from) => type_between, encode_second: (between: type_between) => type_to, from: type_from): type_to; + /** + * @author fenris + */ + function pair_decode(decode_first: (between: type_between) => type_from, decode_second: (to: type_to) => type_between, to: type_to): type_from; +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + class class_code_pair implements interface_code { + /** + * @author fenris + */ + protected first: interface_code; + /** + * @author fenris + */ + protected second: interface_code; + /** + * @author fenris + */ + constructor(first: interface_code, second: interface_code); + /** + * @implementation + * @author fenris + */ + encode(from: type_from): type_to; + /** + * @implementation + * @author fenris + */ + decode(to: type_to): type_from; + } +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + function chain_encode(encode_links: Array<(from: any) => any>, from: any): any; + /** + * @author fenris + */ + function chain_decode(decode_links: Array<(to: any) => any>, to: any): any; +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + class class_code_chain implements interface_code { + /** + * @author fenris + */ + protected links: Array>; + /** + * @author fenris + */ + constructor(links: Array>); + /** + * @implementation + * @author fenris + */ + encode(from: any): any; + /** + * @implementation + * @author fenris + */ + decode(to: any): any; + } +} +declare namespace lib_plankton.code { + /** + * @author Christian Fraß + */ + type type_flatten_from = Array<{ + [name: string]: any; + }>; + /** + * @author Christian Fraß + */ + type type_flatten_to = { + keys: Array; + data: Array>; + }; + /** + * @author Christian Fraß + */ + function flatten_encode(from: type_flatten_from, keys?: Array): type_flatten_to; + /** + * @author Christian Fraß + */ + function flatten_decode(to: type_flatten_to): type_flatten_from; +} +declare namespace lib_plankton.code { + /** + * @author fenris + */ + class class_code_flatten implements interface_code { + /** + * @author fenris + */ + constructor(); + /** + * @implementation + * @author fenris + */ + encode(x: type_flatten_from): type_flatten_to; + /** + * @implementation + * @author fenris + */ + decode(x: type_flatten_to): type_flatten_from; + } +} +declare namespace lib_plankton.json { + /** + */ + type type_source = any; + /** + */ + type type_target = string; + /** + * @author fenris + */ + export function encode(source: type_source, options?: { + formatted?: boolean; + }): type_target; + /** + * @author fenris + */ + export function decode(target: type_target): type_source; + /** + * @author fenris + */ + export function implementation_code(): lib_plankton.code.type_code; + export {}; +} +declare namespace lib_plankton.json { + /** + * @author fenris + */ + class class_json implements lib_plankton.code.interface_code { + /** + * @author fenris + */ + constructor(); + /** + * @implementation + * @author fenris + */ + encode(x: any): string; + /** + * @implementation + * @author fenris + */ + decode(x: string): any; + } +} +declare module lib_plankton.pod { + /** + * @author fenris + */ + type type_pod = { + kind: ("empty" | "filled"); + value?: type_value; + }; + /** + * @author fenris + */ + function make_empty(): type_pod; + /** + * @author fenris + */ + function make_filled(value: type_value): type_pod; + /** + * whether the pod is filled + * + * @author fenris + */ + function is_filled(pod: type_pod): boolean; + /** + * return the value, stored in the pod-wrapper + * + * @author fenris + */ + function cull(pod: type_pod): type_value; + /** + * to pass on a empty-pod or to use a filled-pod + * + * @author fenris + */ + function propagate(pod: type_pod, function_: ((value: type_value) => type_value_)): type_pod; + /** + * @author fenris + */ + function distinguish(pod: type_pod, function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result; + /** + */ + function show(pod: type_pod, options?: { + show_value?: ((value: type_value) => string); + }): string; +} +declare module lib_plankton.pod { + /** + */ + class class_pod { + private subject; + constructor(subject: type_pod); + tear(): type_pod; + static empty(): class_pod; + static filled(value: type_value): class_pod; + is_empty(): boolean; + is_filled(): boolean; + cull(): type_value; + show(show_value?: any): string; + toString(): string; + propagate(function_: ((value: type_value) => type_value_)): class_pod; + distinguish(function_empty: (() => type_result), function_filled: ((value: type_value) => type_result)): type_result; + } +} +/** + * might be completely obsolete + */ +declare namespace lib_plankton.call { + /** + * @author fenris + */ + type type_promise = Promise; + /** + * @author fenris + */ + function promise_reject(reason: type_reason): type_promise; + /** + * @author fenris + */ + function promise_resolve(result: type_result): type_promise; + /** + * @author fenris + */ + function promise_make(executor: (resolve: ((result?: type_result) => void), reject: ((reason?: type_reason) => void)) => void): type_promise; + /** + * @author fenris + */ + function promise_then_close(promise: type_promise, resolver: ((result: type_result) => void), rejector: ((reason: type_reason) => void)): void; + /** + * @author fenris + */ + function promise_then_append(promise: type_promise, resolver: ((result: type_result) => type_promise), rejector?: ((reason: type_reason) => type_promise)): type_promise; + /** + * @author fenris + */ + function promise_all(promises: Array>): type_promise, type_reason>; + /** + * @author fenris + */ + function promise_chain(promises: (Array<(input: type_result) => type_promise>), start?: type_result): type_promise; + /** + * @author fenris + */ + function promise_condense(promises: Array<() => type_promise>): type_promise, type_reason>; + /** + * @author fenris + */ + function promise_group(promises: Record type_promise)>, options?: { + serial?: boolean; + }): type_promise, type_reason>; + /** + * @author fenris + */ + function promise_wrap(promise: type_promise, transformator_result: ((reason: type_result_inner) => type_result_outer), transformator_reason?: ((reason: type_reason) => type_reason)): type_promise; + /** + * @author fenris + */ + /** + * @author fenris + */ + /** + * @author fenris + */ + function promise_attach(state: Record, promise: type_promise, name: string): type_promise, type_reason>; + /** + * @author fenris + */ + function promise_delay(promise: type_promise, delay: int): type_promise; +} +declare namespace lib_plankton.call { + /** + */ + class CancellablePromise extends Promise { + /** + */ + private cancelled; + /** + */ + private interval; + /** + */ + private subject; + /** + */ + constructor(executor: ((resolve: any, reject: any) => void)); + /** + */ + private clear; + /** + */ + then(onfulfilled?: ((value: type_result) => (type_next_resolved | PromiseLike)), onrejected?: ((reason: any) => (type_next_rejected | PromiseLike))): Promise; + /** + */ + catch(x: any): Promise; + /** + */ + cancel(): void; + } +} +/** + * initializer might be obsolete, since promises are reusable after having been resolved or rejected + */ +declare namespace lib_plankton.call { + /** + * @author fenris + */ + enum enum_initializer_state { + initial = 0, + waiting = 1, + successful = 2, + failed = 3 + } + /** + * @author fenris + */ + type type_initializer = { + fetcher: (() => type_promise); + state?: enum_initializer_state; + queue: Array<{ + resolve: ((result?: type_result) => void); + reject: ((reason?: type_reason) => void); + }>; + result?: type_result; + reason?: type_reason; + }; + /** + * @author fenris + */ + function initializer_make(fetcher: (() => type_promise)): type_initializer; + /** + * @author fenris + */ + function initializer_reset(subject: type_initializer): void; + /** + * @author fenris + */ + function initializer_state(subject: type_initializer): enum_initializer_state; + /** + * @author fenris + */ + function initializer_get(subject: type_initializer): type_promise; +} +declare namespace lib_plankton.call { + /** + * @author fenris + */ + type type_deferral = { + representation: (input: type_input) => Promise; + }; + /** + * @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: type_deferral, input: type_input, procedure: (output: type_output) => void): void; + /** + * @author fenris + * @desc creates a deferral-subject (similar to "new Promise", where "convey" reflects "resolve"/"reject") + */ + function deferral_make(handler: (input: type_input, convey: (output: type_output) => void) => void): type_deferral; + /** + * @author fenris + * @desc wraps a simple function into a deferral (similar to "Promise.resolve"/"Promise.reject") + */ + function deferral_wrap(function_: (input: type_input) => type_output): type_deferral; + /** + * @author fenris + */ + function deferral_id(): type_deferral; + /** + * @author fenris + */ + function deferral_const(value: type_value): type_deferral; + /** + * @author fenris + */ + function deferral_delay(output: type_output, delay: int): type_deferral; + /** + * @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} first a simple deferral + * @param {(value1 : type_value1)=>type_deferral} second a function depending from a value returning a deferral + */ + function deferral_compose_serial(first: type_deferral, second: type_deferral): type_deferral; + /** + * @author fenris + */ + function deferral_compose_parallel({ "left": deferral_left, "right": deferral_right, }: { + left: type_deferral; + right: type_deferral; + }): type_deferral; + /** + * @author fenris + * @desc repeatedly applied serial composition + */ + function deferral_chain(members: Array>): type_deferral; + /** + * @author fenris + */ +} +declare namespace lib_plankton.call { + /** + * @author fenris + */ + class class_deferral { + /** + * @author fenris + */ + private subject; + /** + * @author fenris + */ + private constructor(); + /** + * @author fenris + */ + private static _cram; + /** + * @author fenris + */ + private static _tear; + /** + * @author fenris + */ + static make(handler: (input: type_input, convey: (value: type_output) => void) => void): class_deferral; + /** + * @author fenris + */ + use(input: type_input, procedure: (value: type_output) => void): void; + /** + * @author fenris + */ + compose_serial(second: class_deferral): class_deferral; + /** + * @author fenris + */ + static chain(members: Array>): class_deferral; + /** + * @author fenris + */ + static wrap(function_: (input: type_input) => type_output): class_deferral; + /** + * @author fenris + */ + static const_(value: type_value): class_deferral; + /** + * @author fenris + */ + static delay(output: type_output, delay: int): class_deferral; + } +} +declare namespace lib_plankton.call { + /** + * converts the "arguments"-map into an array + * + * @param {Object} args + * @author fenris + */ + function args2list(args: any): Array; + /** + * just the empty function; useful for some callbacks etc. + * + * @author fenris + */ + function nothing(): void; + /** + * just the identity; useful for some callbacks etc.; defined as function instead of const for using type parameters + * + * @author fenris + */ + function id(x: type_value): type_value; + /** + * just the identity; useful for some callbacks etc. + * + * @author fenris + */ + function const_(x: type_value): ((y: any) => type_value); + /** + * composes two functions (i.e. returns a function that return the result of the successive execution of both input-functions) + * + * @param {function} function_f + * @param {function} function_g + * @author fenris + */ + function compose(function_f: ((type_x: any) => type_y), function_g: ((type_y: any) => type_z)): ((value: type_x) => type_z); + /** + * transforms a function with sequential input to a function with leveled input; example: add(2,3) = curryfy(add)(2)(3) + * + * @param {function} f + * @return {function} the currified version of the in put function + * @author fenris + */ + function curryfy(f: Function): Function; + /** + * @author fenris + */ + function convey(value: any, functions: Array): any; + /** + * @author fenris + */ + function timeout(procedure: (() => void), delay_in_seconds: float): int; + /** + * Promise version of "setTimeout" + * + * @author fenris + */ + function defer(seconds: float, action: (() => type_result)): Promise; + /** + * a definition for a value being "defined" + * + * @author neuc + */ + function is_def(obj: type_value, options?: { + null_is_valid?: boolean; + }): boolean; + /** + * returns the value if set and, when a type is specified, if the type is correct, if not return default_value + * + * @author neuc + */ + function def_val(value: any, default_value: any, options?: { + type?: (null | string); + null_is_valid?: boolean; + }): any; + /** + * provides the call for an attribute of a class as a regular function; useful for processing lists of objects + * + * @param {string} name the name of the attribute + * @return {function} + * @author fenris + */ + function attribute(name: string): ((object: type_object) => type_attribute); + /** + * provides a method of a class as a regular function; useful for processing lists of objects + * + * @param {string} name the name of the method + * @return {function} + * @author fenris + */ + function method(name: string): ((object: type_object) => type_output); + /** + * @author fenris + */ + type type_coproduct = { + kind: string; + data?: any; + }; + /** + * @author fenris + */ + function distinguish(coproduct: type_coproduct, handlers: Record type_output)>, options?: { + fallback?: (null | ((coproduct?: type_coproduct) => type_output)); + }): type_output; + /** + * for rate_limit_check + * + * @author fenris + */ + type type_mana_snapshot = { + timestamp: float; + value: float; + }; + /** + * rate limiting algorithm, based on the idea of mana (magic power) in video games: + * - an actor has a fixed mana capacity, i.e. the maximum amount of available power + * - an actor has a fixed rate of mana regeneration, i.e. how fast the power is filled up (linear growth) + * - an action has a defined mana heft, i.e. how much power is required and deducted in order to execute it + * - mana states are represented by snapshots, i.e. the amount of power at a certain point in time + * + * @author fenris + */ + function rate_limit_check(setup: { + capacity: float; + regeneration_rate: float; + get_snapshot: (() => Promise<(null | type_mana_snapshot)>); + set_snapshot: ((snapshot: type_mana_snapshot) => Promise); + update_snapshot: ((timestamp: float, value_increment: float) => Promise); + }, heft: float): Promise<{ + granted: boolean; + seconds: (null | float); + }>; +} +declare namespace lib_plankton.file { + /** + * @author fenris + */ + function exists(path: string): Promise; + /** + * @author fenris + */ + function read(path: string): Promise; + /** + * @author fenris + */ + function read_buffer(path: string): Promise; + /** + * @author fenris + */ + function read_stdin(): Promise; + /** + * @author fenris + */ + function write(path: string, content: string, options?: { + encoding?: string; + }): Promise; + /** + * @author fenris + */ + function write_buffer(path: string, content: Buffer, options?: {}): Promise; + /** + */ + function delete_(path: string): Promise; +} +declare namespace lib_plankton.prog { + /** + */ + abstract class struct_type { + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_literal extends struct_type { + value: struct_expression; + constructor(value: struct_expression); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_any extends struct_type { + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_void extends struct_type { + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_boolean extends struct_type { + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_integer extends struct_type { + constructor(); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_string extends struct_type { + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_list extends struct_type { + element: struct_type; + constructor(element: struct_type); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_map extends struct_type { + key: struct_type; + value: struct_type; + constructor(key: struct_type, value: struct_type); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_record extends struct_type { + fields: Array<{ + name: string; + type: struct_type; + mandatory: boolean; + }>; + constructor(fields: Array<{ + name: string; + type: struct_type; + mandatory: boolean; + }>); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_function extends struct_type { + arguments: Array; + target: struct_type; + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_construction extends struct_type { + name: string; + arguments: (null | Array); + constructor(name: string, arguments_: (null | Array)); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_union extends struct_type { + left: struct_type; + right: struct_type; + constructor(left: struct_type, right: struct_type); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_type_intersection extends struct_type { + left: struct_type; + right: struct_type; + } +} +declare namespace lib_plankton.prog { + /** + */ + abstract class struct_expression { + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_variable extends struct_expression { + name: string; + constructor(name: string); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_literal extends struct_expression { + value: any; + constructor(value: any); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_list extends struct_expression { + elements: Array; + constructor(elements: Array); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_dict extends struct_expression { + fields: Array<{ + key: string; + value: struct_expression; + }>; + constructor(fields: Array<{ + key: string; + value: struct_expression; + }>); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_abstraction extends struct_expression { + arguments: Array<{ + name: string; + type: (null | struct_type); + }>; + output_type: (null | struct_type); + body: Array; + async_: boolean; + constructor(arguments_: Array<{ + name: string; + type: (null | struct_type); + }>, output_type: (null | struct_type), body: Array, options?: { + async?: boolean; + }); + } +} +declare namespace lib_plankton.prog { + /** + * @todo rename to function_call + */ + class struct_expression_function_application extends struct_expression { + head: struct_expression; + arguments: Array; + constructor(head: struct_expression, arguments_: Array); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_projection extends struct_expression { + source: struct_expression; + index: struct_expression; + constructor(source: struct_expression, index: struct_expression); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_fieldaccess extends struct_expression { + structure: struct_expression; + fieldname: string; + constructor(structure: struct_expression, fieldname: string); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_operation_comparison extends struct_expression { + left: struct_expression; + right: struct_expression; + constructor(left: struct_expression, right: struct_expression); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_await extends struct_expression { + target: struct_expression; + constructor(target: struct_expression); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_expression_cast extends struct_expression { + expression: struct_expression; + type: struct_type; + constructor(expression: struct_expression, type: struct_type); + } +} +declare namespace lib_plankton.prog { + /** + */ + abstract class struct_statement { + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_comment extends struct_statement { + block: boolean; + lines: Array; + constructor(block: boolean, lines: Array); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_block extends struct_statement { + statements: Array; + constructor(statements: Array); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_type_definition extends struct_statement { + name: string; + type: struct_type; + export_: boolean; + constructor(name: string, type: struct_type, options?: { + export?: boolean; + }); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_declaration extends struct_statement { + constant: boolean; + name: string; + type: (null | struct_type); + value: (null | struct_expression); + export_: boolean; + constructor(constant: boolean, name: string, type: (null | struct_type), value: (null | struct_expression), options?: { + export?: boolean; + }); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_assignment extends struct_statement { + name: string; + value: (null | struct_expression); + constructor(name: string, value: (null | struct_expression)); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_procedure_call extends struct_statement { + head: struct_expression; + arguments: Array; + constructor(head: struct_expression, arguments_: Array); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_function_definition extends struct_statement { + name: string; + arguments: Array<{ + name: string; + type: (null | struct_type); + }>; + output_type: (null | struct_type); + body: Array; + async_: boolean; + constructor(name: string, arguments_: Array<{ + name: string; + type: (null | struct_type); + }>, output_type: (null | struct_type), body: Array, options?: { + async?: boolean; + }); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_statement_return extends struct_statement { + expression: struct_expression; + constructor(expression: struct_expression); + } +} +declare namespace lib_plankton.prog { + /** + */ + class struct_program { + statements: Array; + constructor(statements: Array); + } +} +declare namespace lib_plankton.prog { + /** + */ + type type_output = { + render_expression: ((expression: struct_expression) => string); + render_type: ((type: struct_type) => string); + render_statement: ((program: struct_statement) => string); + render_program: ((program: struct_program) => string); + }; +} +declare namespace lib_plankton.prog.typescript { + /** + */ + function render_type(type: struct_type, options?: { + indent?: boolean; + level?: int; + }): string; + /** + */ + function render_expression(expression: struct_expression, options?: { + indent?: boolean; + level?: int; + }): string; + /** + */ + function render_statement(statement: struct_statement, options?: { + indent?: boolean; + level?: int; + }): string; + /** + */ + function render_program(program: struct_program): string; + /** + */ + function output_typescript(): type_output; +} +declare namespace lib_plankton.args { + /** + */ + enum enum_environment { + cli = "cli", + url = "url" + } + /** + */ + enum enum_kind { + positional = "positional", + volatile = "volatile" + } + /** + */ + enum enum_type { + boolean = "boolean", + integer = "int", + float = "float", + string = "string" + } + /** + */ + enum enum_mode { + replace = "replace", + accumulate = "accumulate" + } +} +declare namespace lib_plankton.args { + /** + * @author fenris + */ + class class_argument { + /** + * @author fenris + */ + protected name: string; + /** + * @author fenris + */ + protected kind: enum_kind; + /** + * @author fenris + */ + protected type: enum_type; + /** + * @author fenris + */ + protected mode: enum_mode; + /** + * @author fenris + */ + protected default_: any; + /** + * @author fenris + */ + protected info: string; + /** + * @author fenris + */ + protected parameters: Object; + /** + * @author fenris + */ + protected hidden: boolean; + /** + * @author fenris + */ + constructor({ "name": name, "type": type, "kind": kind, "mode": mode, "default": default_, "info": info, "parameters": parameters, "hidden": hidden, }: { + name: string; + type?: enum_type; + kind?: enum_kind; + mode?: enum_mode; + default?: any; + info?: string; + parameters?: Object; + hidden?: boolean; + }); + /** + * @author fenris + */ + static positional({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "index": index, }: { + name: string; + type?: enum_type; + mode?: enum_mode; + default?: any; + info?: string; + hidden?: boolean; + index: int; + }): class_argument; + /** + * @author fenris + */ + static volatile({ "name": name, "type": type, "mode": mode, "default": default_, "info": info, "hidden": hidden, "indicators_short": indicators_short, "indicators_long": indicators_long, }: { + name: string; + type?: enum_type; + mode?: enum_mode; + default?: any; + info?: string; + hidden?: boolean; + indicators_short: Array; + indicators_long: Array; + }): class_argument; + /** + * @author fenris + */ + check(): boolean; + /** + * @author fenris + */ + name_get(): string; + /** + * @author fenris + */ + kind_get(): enum_kind; + /** + * @author fenris + */ + type_get(): enum_type; + /** + * @author fenris + */ + mode_get(): enum_mode; + /** + * @author fenris + */ + default_get(): any; + /** + * @author fenris + */ + parameters_get(): Object; + /** + * @author fenris + */ + hidden_get(): boolean; + /** + * @author fenris + */ + toString(): string; + /** + * @author fenris + */ + indicator_main(): string; + /** + * @author fenris + */ + pattern_value(): string; + /** + * @author fenris + */ + extract(raw: string): any; + /** + * @author fenris + */ + assign(data: Object, target: string, raw: string): void; + /** + * @author fenris + */ + make(data: Object, target: string): string; + /** + * @author fenris + */ + generate_help(): string; + } +} +declare namespace lib_plankton.args { + /** + * @author fenris + */ + var verbosity: int; + /** + * @author fenris + * @todo check validity + */ + class class_handler { + /** + * @author fenris + */ + protected arguments_: { + [name: string]: class_argument; + }; + /** + * @author fenris + */ + constructor(arguments_: { + [name: string]: class_argument; + }); + /** + * @author fenris + */ + filter(kind: enum_kind): { + [name: string]: class_argument; + }; + /** + * @author fenris + */ + read(environment: enum_environment, input: string, data?: { + [name: string]: any; + }): { + [name: string]: any; + }; + /** + * @author fenris + * @todo handle if the data object doesn't have the required field or the type is wrong or sth. + */ + write(environment: enum_environment, data: { + [name: string]: any; + }): string; + /** + * @desc manpage-like info-sheet + * @author fenris + */ + generate_help({ "programname": programname, "author": author, "description": description, "executable": executable, }: { + programname?: string; + author?: string; + description?: string; + executable?: string; + }): string; + } +} diff --git a/lib/plankton/plankton.js b/lib/plankton/plankton.js new file mode 100644 index 0000000..bceb84b --- /dev/null +++ b/lib/plankton/plankton.js @@ -0,0 +1,6668 @@ +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +/* +This file is part of »bacterio-plankton:base«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +// } +/* +This file is part of »bacterio-plankton:base«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +; +var lib_plankton; +(function (lib_plankton) { + var base; + (function (base) { + /** + * @author fenris + */ + function environment() { + return "node"; + } + 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' + + +»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 . + */ +/** + * @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 { + var 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' + + +»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 . + */ +/** + * @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' + + +»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 . + */ +/** + * @author frac + */ +var class_observer = /** @class */ (function () { + /** + * @author frac + */ + function class_observer() { + this.counter = 0; + this.actions = {}; + this.buffer = []; + } + /** + * @author frac + */ + class_observer.prototype.empty = function () { + return (Object.keys(this.actions).length == 0); + }; + /** + * @author frac + */ + class_observer.prototype.flush = function () { + this.actions = {}; + }; + /** + * @author frac + */ + class_observer.prototype.set = function (id, action) { + this.actions[id] = action; + }; + /** + * @author frac + */ + class_observer.prototype.del = function (id) { + delete this.actions[id]; + }; + /** + * @author frac + */ + class_observer.prototype.add = function (action) { + this.set((this.counter++).toString(), action); + }; + /** + * @author frac + */ + class_observer.prototype.notify = function (information, delayed) { + var _this = this; + if (information === void 0) { information = {}; } + if (delayed === void 0) { delayed = false; } + if (delayed) { + this.buffer.push(information); + } + else { + Object.keys(this.actions).forEach(function (id) { return _this.actions[id](information); }); + } + }; + /** + * @author frac + */ + class_observer.prototype.rollout = function () { + var _this = this; + this.buffer.forEach(function (information) { return _this.notify(information, false); }); + this.buffer = []; + }; + return class_observer; +}()); +/** + * @author frac + */ +/* +export interface interface_readable { + + |** + * @author frac + *| + read() : type_executor; + +} + */ +/** + * @author frac + */ +/* +export interface interface_writeable { + + |** + * @author frac + *| + write(value : type_value) : type_executor; + +} + */ +/* +This file is part of »bacterio-plankton:base«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +/** + * @author frac + */ +var class_error = /** @class */ (function (_super) { + __extends(class_error, _super); + /** + * @author frac + */ + function class_error(message, suberrors) { + if (suberrors === void 0) { suberrors = []; } + var _this = _super.call(this, message) || this; + _this.suberrors = suberrors; + _this.mess = message; + return _this; + } + /** + * @override + * @author frac + */ + class_error.prototype.toString = function () { + return ( /*super.toString()*/this.mess + " " + ("[" + this.suberrors.map(function (x) { return x.toString(); }).join(",") + "]")); + }; + return class_error; +}(Error)); +/* +This file is part of »bacterio-plankton:base«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var base; + (function (base) { + /** + * returns the current UNIX timestamp + * + * @author fenris + */ + function get_current_timestamp(rounded) { + if (rounded === void 0) { rounded = false; } + var 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; + })(base = lib_plankton.base || (lib_plankton.base = {})); +})(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' + + +»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 . + */ +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 () { + var nm_nodemailer, transporter, info; + return __generator(this, function (_a) { + switch (_a.label) { + case 0: + nm_nodemailer = require("nodemailer"); + transporter = nm_nodemailer.createTransport({ + "host": smtp_credentials.host, + "port": smtp_credentials.port, + "secure": false, + "auth": { + "user": smtp_credentials.username, + "pass": smtp_credentials.password + }, + "debug": true + }); + return [4 /*yield*/, transporter.sendMail({ + "from": sender, + "to": receivers.join(", "), + "subject": subject, + "text": content + })]; + case 1: + info = _a.sent(); + return [2 /*return*/]; + } + }); + }); + } + email.send = send; + })(email = lib_plankton.email || (lib_plankton.email = {})); +})(lib_plankton || (lib_plankton = {})); +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +/* +This file is part of »bacterio-plankton:log«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +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 = {})); + ; + /** + */ + function level_order(level1, level2) { + return (level1 <= level2); + } + log.level_order = level_order; + /** + */ + function level_show(level) { + switch (level) { + case enum_level.debug: return "debug"; + case enum_level.info: return "info"; + case enum_level.notice: return "notice"; + case enum_level.warning: return "warning"; + case enum_level.error: return "error"; + default: return "(unknown)"; + } + } + log.level_show = level_show; + })(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' + + +»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:lang«. If not, see . + */ +/** + * @deprecated + * @todo remove + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + * @author fenris + */ + /*export*/ var level_stack = [0]; + function level_push(level) { level_stack.push(level); } + log.level_push = level_push; + function level_pop() { if (level_stack.length > 1) { + level_stack.pop(); + } } + log.level_pop = level_pop; + function level_get() { return level_stack.slice(-1)[0]; } + /* + export function level_inc() : void {level_push(level_get()+1);} + export function level_dec() : void {level_push(level_get()-1);} + */ + /** + * @author fenris + */ + var indent_stack = [0]; + function indent_push(indent) { indent_stack.push(indent); } + log.indent_push = indent_push; + function indent_pop() { if (indent_stack.length > 1) { + indent_stack.pop(); + } } + log.indent_pop = indent_pop; + function indent_get() { return level_stack.slice(-1)[0]; } + function indent_inc() { level_push(level_get() + 1); } + log.indent_inc = indent_inc; + function indent_dec() { level_push(level_get() - 1); } + log.indent_dec = indent_dec; + /** + * @author fenris + */ + function write(_a) { + var message = _a["message"], _b = _a["type"], type = _b === void 0 ? null : _b, _c = _a["prefix"], prefix = _c === void 0 ? null : _c, _d = _a["level"], level = _d === void 0 ? 0 : _d, _e = _a["indent"], indent = _e === void 0 ? 0 : _e; + var entry = { + "level": ((type === null) + ? lib_plankton.log.enum_level.info + : { + "debug": lib_plankton.log.enum_level.debug, + "info": lib_plankton.log.enum_level.info, + "notice": lib_plankton.log.enum_level.notice, + "warning": lib_plankton.log.enum_level.warning, + "error": lib_plankton.log.enum_level.error + }[type]), + "incident": message, + "details": { + "prefix": prefix, + "level": level, + "indent": indent + } + }; + lib_plankton.log.add(entry); + } + log.write = write; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + */ + var class_channel = /** @class */ (function () { + function class_channel() { + } + return class_channel; + }()); + log.class_channel = class_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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + * output for writing log entries to stdout + */ + var class_channel_stdout = /** @class */ (function (_super) { + __extends(class_channel_stdout, _super); + function class_channel_stdout() { + return _super !== null && _super.apply(this, arguments) || this; + } + /** + */ + class_channel_stdout.prototype.add = function (entry) { + process.stdout.write(("<" + (new Date(Date.now())).toISOString().slice(0, 19) + ">") + + + " " + + + ("[" + log.level_show(entry.level) + "]") + + + " " + + + ("" + entry.incident + "") + + + ": " + + + JSON.stringify(entry.details, undefined, " ") + + + "\n"); + }; + return class_channel_stdout; + }(log.class_channel)); + log.class_channel_stdout = class_channel_stdout; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + */ + var class_channel_file = /** @class */ (function (_super) { + __extends(class_channel_file, _super); + /** + * [constructor] + */ + function class_channel_file(path, human_readable) { + var _this = _super.call(this) || this; + _this.path = path; + _this.human_readable = human_readable; + return _this; + } + /** + */ + class_channel_file.prototype.add = function (entry) { + var _this = this; + var nm_fs = require("fs"); + var line = (this.human_readable + ? (("<" + (new Date(Date.now())).toISOString().slice(0, 19) + ">") + + + " " + + + ("[" + log.level_show(entry.level) + "]") + + + " " + + + ("" + entry.incident + "") + + + ": " + + + JSON.stringify(entry.details, undefined, " ") + + + "\n") + : (JSON.stringify({ + "timestamp": lib_plankton.base.get_current_timestamp(), + "level_number": entry.level, + "level_name": log.level_show(entry.level), + "incident": entry.incident, + "details": entry.details + }) + + + "\n")); + nm_fs.writeFile(this.path, line, { + "flag": "a+" + }, function (error) { + if (error !== null) { + process.stderr.write('-- [plankton] could not add log entry to file ' + _this.path + "\n"); + } + else { + // do nothing + } + }); + }; + return class_channel_file; + }(log.class_channel)); + log.class_channel_file = class_channel_file; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + */ + var class_channel_email = /** @class */ (function (_super) { + __extends(class_channel_email, _super); + /** + * [constructor] + */ + function class_channel_email(smtp_credentials, sender, receivers) { + var _this = _super.call(this) || this; + _this.smtp_credentials = smtp_credentials; + _this.sender = sender; + _this.receivers = receivers; + return _this; + } + /** + */ + class_channel_email.prototype.add = function (entry) { + var nm_fs = require("fs"); + lib_plankton.email.send(this.smtp_credentials, this.sender, this.receivers, (("[" + log.level_show(entry.level) + "]") + + + " " + + + ("" + entry.incident + "")), JSON.stringify(entry.details, undefined, " ")); + }; + return class_channel_email; + }(log.class_channel)); + log.class_channel_email = class_channel_email; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + * output for desktop notifications via "libnotify" + */ + var class_channel_notify = /** @class */ (function (_super) { + __extends(class_channel_notify, _super); + function class_channel_notify() { + return _super !== null && _super.apply(this, arguments) || this; + } + /** + */ + class_channel_notify.prototype.add = function (entry) { + var nm_child_process = require("child_process"); + var command = ("notify-send" + + + " " + + + ("'" + + + ("[" + log.level_show(entry.level) + "]") + + + " " + + + entry.incident + + + "'") + + + " " + + + ("'" + + + (Object.keys(entry.details) + .map(function (key) { return (key + ": " + JSON.stringify(entry.details[key])); }) + .join("\n")) + + + "'")); + nm_child_process.exec(command, function (error, stdout, stderr) { + // do noting + }); + }; + return class_channel_notify; + }(log.class_channel)); + log.class_channel_notify = class_channel_notify; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + * decorator for filtering out log entries below a certain level threshold + */ + var class_channel_minlevel = /** @class */ (function (_super) { + __extends(class_channel_minlevel, _super); + /** + */ + function class_channel_minlevel(core, threshold) { + var _this = _super.call(this) || this; + _this.core = core; + _this.threshold = threshold; + return _this; + } + /** + */ + class_channel_minlevel.prototype.add = function (entry) { + if (!log.level_order(this.threshold, entry.level)) { + // do nothing + } + else { + this.core.add(entry); + } + }; + return class_channel_minlevel; + }(log.class_channel)); + log.class_channel_minlevel = class_channel_minlevel; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + */ + function translate_level(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]; + } + /** + */ + function channel_make(description) { + var _a, _b, _c, _d, _e; + switch (description.kind) { + default: { + throw (new Error("unhandled log channel kind: " + description.kind)); + break; + } + case "stdout": { + return (new log.class_channel_minlevel(new log.class_channel_stdout(), translate_level((_a = description.data["threshold"]) !== null && _a !== void 0 ? _a : "debug"))); + break; + } + case "file": { + return (new log.class_channel_minlevel(new log.class_channel_file(((_b = description.data["path"]) !== null && _b !== void 0 ? _b : "/tmp/plankton.log"), false), translate_level((_c = description.data["threshold"]) !== null && _c !== void 0 ? _c : "debug"))); + break; + } + case "email": { + return (new log.class_channel_minlevel(new log.class_channel_email(description.data["smtp_credentials"], description.data["sender"], description.data["receivers"]), translate_level((_d = description.data["threshold"]) !== null && _d !== void 0 ? _d : "debug"))); + break; + } + case "notify": { + return (new log.class_channel_minlevel(new log.class_channel_notify(), translate_level((_e = description.data["threshold"]) !== null && _e !== void 0 ? _e : "debug"))); + break; + } + } + } + log.channel_make = channel_make; + /** + */ + function conf_default() { + return [ + new log.class_channel_minlevel(new log.class_channel_stdout(), log.enum_level.notice), + new log.class_channel_minlevel(new log.class_channel_notify(), log.enum_level.error), + ]; + } + log.conf_default = conf_default; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + */ + var _channel_stack = null; + /** + * pushes a new configuration on the stack and activates it + */ + function conf_push(channels) { + if (_channel_stack === null) { + _channel_stack = []; + } + _channel_stack.push(channels); + } + log.conf_push = conf_push; + /** + * pops the current active configuration from the stack + */ + function conf_pop() { + if (_channel_stack.length > 0) { + _channel_stack.pop(); + } + else { + // do nothing + } + } + log.conf_pop = conf_pop; + /** + * makes the logging system ready + */ + function setup() { + if (_channel_stack === null) { + _channel_stack = []; + conf_push(log.conf_default()); + } + else { + // do nothing + } + } + /** + * consumes a log entry, i.e. sends it to the currently active outputs + */ + function add(entry) { + setup(); + _channel_stack.slice(-1)[0].forEach(function (channel) { return channel.add(entry); }); + } + log.add = add; + /** + */ + function debug(incident, details) { + if (details === void 0) { details = {}; } + add({ "level": log.enum_level.debug, "incident": incident, "details": details }); + } + log.debug = debug; + /** + */ + function info(incident, details) { + if (details === void 0) { details = {}; } + add({ "level": log.enum_level.info, "incident": incident, "details": details }); + } + log.info = info; + /** + */ + function notice(incident, details) { + if (details === void 0) { details = {}; } + add({ "level": log.enum_level.notice, "incident": incident, "details": details }); + } + log.notice = notice; + /** + */ + function warning(incident, details) { + if (details === void 0) { details = {}; } + add({ "level": log.enum_level.warning, "incident": incident, "details": details }); + } + log.warning = warning; + /** + */ + function error(incident, details) { + if (details === void 0) { details = {}; } + add({ "level": log.enum_level.error, "incident": incident, "details": details }); + } + log.error = error; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var log; + (function (log) { + /** + */ + log.conf_push([ + log.channel_make({ + "kind": "stdout", + "data": { + "threshold": "info" + } + }), + ]); + })(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' + + +»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 . + */ +var plain_text_to_html = function (text) { + let ret = text; + ret = ret.replace(/ /g, "  "); // convert multiple whitespace to forced ones + ret = ret.split("\n").join("
"); + 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: "

foo

" }, {...}] + 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' + + +»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 . + */ +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) { + 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} + * @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; + })(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' + + +»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 . + */ +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' + + +»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 . + */ +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:code«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +/* +This file is part of »bacterio-plankton:code«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +/* +This file is part of »bacterio-plankton:code«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +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' + + +»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 . + */ +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' + + +»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 . + */ +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' + + +»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 . + */ +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' + + +»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 . + */ +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' + + +»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 . + */ +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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var code; + (function (code) { + /** + * @author Christian Fraß + */ + 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ß + */ + 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' + + +»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 . + */ +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' + + +»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 . + */ +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' + + +»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 . + */ +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:pod«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»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 . + */ +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' + + +»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 . + */ +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' + + +»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 . + */ +/** + * 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(label : string) : (result : type_result)=>type_promise { + return ( + result => promise_make( + (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(result : type_result) : (result : type_result)=>type_promise { + return promise_show("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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var call; + (function (call) { + /** + */ + class CancellablePromise extends Promise { + /** + */ + constructor(executor) { + super((resolve, reject) => { }); + this.subject = (new Promise((resolve, reject) => { + Promise.race([ + new Promise(executor), + new Promise((resolve_, reject_) => { + this.interval = setInterval(() => { + if (!this.cancelled) { + // do nothing + } + else { + reject_(new Error("cancelled")); + this.clear(); + } + }, 0); + }), + ]) + .then(resolve, reject); + })); + this.cancelled = false; + this.interval = null; + } + /** + */ + clear() { + if (this.interval === null) { + // do nothing + } + else { + clearInterval(this.interval); + this.interval = null; + } + } + /** + */ + then(onfulfilled, onrejected) { + this.clear(); + return this.subject.then(onfulfilled, onrejected); + } + /** + */ + catch(x) { + this.clear(); + return this.subject.catch(x); + } + /** + */ + cancel() { + this.cancelled = true; + this.clear(); + } + } + call.CancellablePromise = CancellablePromise; + })(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' + + +»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 . + */ +/** + * 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' + + +»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 . + */ +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} first a simple deferral + * @param {(value1 : type_value1)=>type_deferral} 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(result, current), + deferral_compose_serial, deferral_id())); + } + call.deferral_chain = deferral_chain; + /** + * @author fenris + */ + /* + export function deferral_bunch( + members : {[name : string] : type_deferral} + ) : type_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' + + +»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 . + */ +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' + + +»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 . + */ +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; + /** + * @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; + /** + * rate limiting algorithm, based on the idea of mana (magic power) in video games: + * - an actor has a fixed mana capacity, i.e. the maximum amount of available power + * - an actor has a fixed rate of mana regeneration, i.e. how fast the power is filled up (linear growth) + * - an action has a defined mana heft, i.e. how much power is required and deducted in order to execute it + * - mana states are represented by snapshots, i.e. the amount of power at a certain point in time + * + * @author fenris + */ + async function rate_limit_check(setup, heft) { + if (heft > setup.capacity) { + return Promise.resolve({ + "granted": false, + "seconds": null, + }); + } + else { + // get current value + const current_timestamp = (Date.now() / 1000); + const old_snapshot_raw = (await setup.get_snapshot()); + const old_snapshot = (old_snapshot_raw + ?? + { "timestamp": current_timestamp, "value": setup.capacity }); + const seconds_passed = (current_timestamp - old_snapshot.timestamp); + const current_value = Math.min(setup.capacity, (old_snapshot.value + + + (setup.regeneration_rate + * + seconds_passed))); + // analyze + if (current_value < heft) { + // too less + const seconds_needed = ((setup.regeneration_rate <= 0) + ? null + : ((heft - old_snapshot.value) / setup.regeneration_rate)); + return Promise.resolve({ + "granted": false, + "seconds": ((seconds_needed === null) ? null : (seconds_needed - seconds_passed)), + }); + } + else { + // enough -> update snapshot + const new_value = (current_value - heft); + // set_snapshot + if (old_snapshot_raw === null) { + await setup.set_snapshot({ "timestamp": current_timestamp, "value": new_value }); + } + else { + await setup.update_snapshot(current_timestamp, (new_value - old_snapshot.value)); + } + return Promise.resolve({ + "granted": true, + "seconds": 0, + }); + } + } + } + call.rate_limit_check = rate_limit_check; + })(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' + + +»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 . + */ +var lib_plankton; +(function (lib_plankton) { + var file; + (function (file) { + /** + * @author fenris + */ + function exists(path) { + var nm_fs = require("fs"); + return (new Promise(function (resolve, reject) { + nm_fs.stat(path, function (error, stats) { + if (error) { + resolve(false); + } + else { + resolve(true); + } + }); + })); + } + file.exists = exists; + /** + * @author fenris + */ + function read(path) { + var nm_fs = require("fs"); + return (new Promise(function (resolve, reject) { + nm_fs.readFile(path, { + "encoding": "utf8", + "flag": "r" + }, function (error, content) { + if (error == null) { + resolve(content); + } + else { + reject(error); + } + }); + })); + } + file.read = read; + /** + * @author fenris + */ + function read_buffer(path) { + var nm_fs = require("fs"); + return (new Promise(function (resolve, reject) { + nm_fs.readFile(path, { + "flag": "r" + }, function (error, content) { + if (error == null) { + resolve(content); + } + else { + reject(error); + } + }); + })); + } + file.read_buffer = read_buffer; + /** + * @author fenris + */ + function read_stdin() { + return (new Promise(function (resolve, reject) { + var input_raw = ""; + process.stdin.setEncoding("utf8"); + process.stdin.on("readable", function () { + var chunk; + while ((chunk = process.stdin.read()) !== null) { + input_raw += chunk; + } + }); + process.stdin.on("end", function () { + resolve(input_raw); + }); + })); + } + file.read_stdin = read_stdin; + /** + * @author fenris + */ + function write(path, content, options) { + if (options === void 0) { options = {}; } + options = Object.assign({ + "encoding": "utf-8" + }, options); + var nm_fs = require("fs"); + return (new Promise(function (resolve, reject) { + nm_fs.writeFile(path, content, { + "encoding": options.encoding, + "flag": "w" + }, function (error) { + if (error == null) { + resolve(undefined); + } + else { + reject(error); + } + }); + })); + } + file.write = write; + /** + * @author fenris + */ + function write_buffer(path, content, options) { + if (options === void 0) { options = {}; } + options = Object.assign({}, options); + var nm_fs = require("fs"); + return (new Promise(function (resolve, reject) { + nm_fs.writeFile(path, content, { + "flag": "w" + }, function (error) { + if (error == null) { + resolve(undefined); + } + else { + reject(error); + } + }); + })); + } + file.write_buffer = write_buffer; + /** + */ + function delete_(path) { + var nm_fs = require("fs"); + return (new Promise(function (resolve, reject) { + nm_fs.unlink(path, function () { + resolve(undefined); + }); + })); + } + file.delete_ = delete_; + })(file = lib_plankton.file || (lib_plankton.file = {})); +})(lib_plankton || (lib_plankton = {})); +var __extends = (this && this.__extends) || (function () { + var extendStatics = function (d, b) { + extendStatics = Object.setPrototypeOf || + ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || + function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; }; + return extendStatics(d, b); + }; + return function (d, b) { + if (typeof b !== "function" && b !== null) + throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); + extendStatics(d, b); + function __() { this.constructor = d; } + d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); + }; +})(); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type = /** @class */ (function () { + function struct_type() { + } + return struct_type; + }()); + prog.struct_type = struct_type; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_literal = /** @class */ (function (_super) { + __extends(struct_type_literal, _super); + function struct_type_literal(value) { + var _this = _super.call(this) || this; + _this.value = value; + return _this; + } + return struct_type_literal; + }(prog.struct_type)); + prog.struct_type_literal = struct_type_literal; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_any = /** @class */ (function (_super) { + __extends(struct_type_any, _super); + function struct_type_any() { + return _super !== null && _super.apply(this, arguments) || this; + } + return struct_type_any; + }(prog.struct_type)); + prog.struct_type_any = struct_type_any; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_void = /** @class */ (function (_super) { + __extends(struct_type_void, _super); + function struct_type_void() { + return _super !== null && _super.apply(this, arguments) || this; + } + return struct_type_void; + }(prog.struct_type)); + prog.struct_type_void = struct_type_void; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_boolean = /** @class */ (function (_super) { + __extends(struct_type_boolean, _super); + function struct_type_boolean() { + return _super !== null && _super.apply(this, arguments) || this; + } + return struct_type_boolean; + }(prog.struct_type)); + prog.struct_type_boolean = struct_type_boolean; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_integer = /** @class */ (function (_super) { + __extends(struct_type_integer, _super); + function struct_type_integer() { + return _super.call(this) || this; + } + return struct_type_integer; + }(prog.struct_type)); + prog.struct_type_integer = struct_type_integer; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_string = /** @class */ (function (_super) { + __extends(struct_type_string, _super); + function struct_type_string() { + return _super !== null && _super.apply(this, arguments) || this; + } + return struct_type_string; + }(prog.struct_type)); + prog.struct_type_string = struct_type_string; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_list = /** @class */ (function (_super) { + __extends(struct_type_list, _super); + function struct_type_list(element) { + var _this = _super.call(this) || this; + _this.element = element; + return _this; + } + return struct_type_list; + }(prog.struct_type)); + prog.struct_type_list = struct_type_list; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_map = /** @class */ (function (_super) { + __extends(struct_type_map, _super); + function struct_type_map(key, value) { + var _this = _super.call(this) || this; + _this.key = key; + _this.value = value; + return _this; + } + return struct_type_map; + }(prog.struct_type)); + prog.struct_type_map = struct_type_map; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_record = /** @class */ (function (_super) { + __extends(struct_type_record, _super); + function struct_type_record(fields) { + var _this = _super.call(this) || this; + _this.fields = fields; + return _this; + } + return struct_type_record; + }(prog.struct_type)); + prog.struct_type_record = struct_type_record; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_function = /** @class */ (function (_super) { + __extends(struct_type_function, _super); + function struct_type_function() { + return _super !== null && _super.apply(this, arguments) || this; + } + return struct_type_function; + }(prog.struct_type)); + prog.struct_type_function = struct_type_function; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_construction = /** @class */ (function (_super) { + __extends(struct_type_construction, _super); + function struct_type_construction(name, arguments_) { + var _this = _super.call(this) || this; + _this.name = name; + _this.arguments = arguments_; + return _this; + } + return struct_type_construction; + }(prog.struct_type)); + prog.struct_type_construction = struct_type_construction; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_union = /** @class */ (function (_super) { + __extends(struct_type_union, _super); + function struct_type_union(left, right) { + var _this = _super.call(this) || this; + _this.left = left; + _this.right = right; + return _this; + } + return struct_type_union; + }(prog.struct_type)); + prog.struct_type_union = struct_type_union; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_type_intersection = /** @class */ (function (_super) { + __extends(struct_type_intersection, _super); + function struct_type_intersection() { + return _super !== null && _super.apply(this, arguments) || this; + } + return struct_type_intersection; + }(prog.struct_type)); + prog.struct_type_intersection = struct_type_intersection; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression = /** @class */ (function () { + function struct_expression() { + } + return struct_expression; + }()); + prog.struct_expression = struct_expression; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_variable = /** @class */ (function (_super) { + __extends(struct_expression_variable, _super); + function struct_expression_variable(name) { + var _this = _super.call(this) || this; + _this.name = name; + return _this; + } + return struct_expression_variable; + }(prog.struct_expression)); + prog.struct_expression_variable = struct_expression_variable; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_literal = /** @class */ (function (_super) { + __extends(struct_expression_literal, _super); + function struct_expression_literal(value) { + var _this = _super.call(this) || this; + _this.value = value; + return _this; + } + return struct_expression_literal; + }(prog.struct_expression)); + prog.struct_expression_literal = struct_expression_literal; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_list = /** @class */ (function (_super) { + __extends(struct_expression_list, _super); + function struct_expression_list(elements) { + var _this = _super.call(this) || this; + _this.elements = elements; + return _this; + } + return struct_expression_list; + }(prog.struct_expression)); + prog.struct_expression_list = struct_expression_list; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_dict = /** @class */ (function (_super) { + __extends(struct_expression_dict, _super); + function struct_expression_dict(fields) { + var _this = _super.call(this) || this; + _this.fields = fields; + return _this; + } + return struct_expression_dict; + }(prog.struct_expression)); + prog.struct_expression_dict = struct_expression_dict; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_abstraction = /** @class */ (function (_super) { + __extends(struct_expression_abstraction, _super); + function struct_expression_abstraction(arguments_, output_type, body, options) { + if (options === void 0) { options = {}; } + var _this = this; + options = Object.assign({ + "async": false + }, options); + _this = _super.call(this) || this; + _this.arguments = arguments_; + _this.output_type = output_type; + _this.body = body; + _this.async_ = options.async; + return _this; + } + return struct_expression_abstraction; + }(prog.struct_expression)); + prog.struct_expression_abstraction = struct_expression_abstraction; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + * @todo rename to function_call + */ + var struct_expression_function_application = /** @class */ (function (_super) { + __extends(struct_expression_function_application, _super); + function struct_expression_function_application(head, arguments_) { + var _this = _super.call(this) || this; + _this.head = head; + _this.arguments = arguments_; + return _this; + } + return struct_expression_function_application; + }(prog.struct_expression)); + prog.struct_expression_function_application = struct_expression_function_application; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_projection = /** @class */ (function (_super) { + __extends(struct_expression_projection, _super); + function struct_expression_projection(source, index) { + var _this = _super.call(this) || this; + _this.source = source; + _this.index = index; + return _this; + } + return struct_expression_projection; + }(prog.struct_expression)); + prog.struct_expression_projection = struct_expression_projection; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_fieldaccess = /** @class */ (function (_super) { + __extends(struct_expression_fieldaccess, _super); + function struct_expression_fieldaccess(structure, fieldname) { + var _this = _super.call(this) || this; + _this.structure = structure; + _this.fieldname = fieldname; + return _this; + } + return struct_expression_fieldaccess; + }(prog.struct_expression)); + prog.struct_expression_fieldaccess = struct_expression_fieldaccess; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_operation_comparison = /** @class */ (function (_super) { + __extends(struct_expression_operation_comparison, _super); + function struct_expression_operation_comparison(left, right) { + var _this = _super.call(this) || this; + _this.left = left; + _this.right = right; + return _this; + } + return struct_expression_operation_comparison; + }(prog.struct_expression)); + prog.struct_expression_operation_comparison = struct_expression_operation_comparison; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_await = /** @class */ (function (_super) { + __extends(struct_expression_await, _super); + function struct_expression_await(target) { + var _this = _super.call(this) || this; + _this.target = target; + return _this; + } + return struct_expression_await; + }(prog.struct_expression)); + prog.struct_expression_await = struct_expression_await; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_expression_cast = /** @class */ (function (_super) { + __extends(struct_expression_cast, _super); + function struct_expression_cast(expression, type) { + var _this = _super.call(this) || this; + _this.expression = expression; + _this.type = type; + return _this; + } + return struct_expression_cast; + }(prog.struct_expression)); + prog.struct_expression_cast = struct_expression_cast; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement = /** @class */ (function () { + function struct_statement() { + } + return struct_statement; + }()); + prog.struct_statement = struct_statement; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_comment = /** @class */ (function (_super) { + __extends(struct_statement_comment, _super); + function struct_statement_comment(block, lines) { + var _this = _super.call(this) || this; + _this.block = block; + _this.lines = lines; + return _this; + } + return struct_statement_comment; + }(prog.struct_statement)); + prog.struct_statement_comment = struct_statement_comment; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_block = /** @class */ (function (_super) { + __extends(struct_statement_block, _super); + function struct_statement_block(statements) { + var _this = _super.call(this) || this; + _this.statements = statements; + return _this; + } + return struct_statement_block; + }(prog.struct_statement)); + prog.struct_statement_block = struct_statement_block; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_type_definition = /** @class */ (function (_super) { + __extends(struct_statement_type_definition, _super); + function struct_statement_type_definition(name, type, options) { + if (options === void 0) { options = {}; } + var _this = this; + options = Object.assign({ + "export": false + }, options); + _this = _super.call(this) || this; + _this.name = name; + _this.type = type; + _this.export_ = options["export"]; + return _this; + } + return struct_statement_type_definition; + }(prog.struct_statement)); + prog.struct_statement_type_definition = struct_statement_type_definition; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_declaration = /** @class */ (function (_super) { + __extends(struct_statement_declaration, _super); + function struct_statement_declaration(constant, name, type, value, options) { + if (options === void 0) { options = {}; } + var _this = this; + options = Object.assign({ + "export": false + }, options); + _this = _super.call(this) || this; + _this.constant = constant; + _this.name = name; + _this.type = type; + _this.value = value; + _this.export_ = options["export"]; + return _this; + } + return struct_statement_declaration; + }(prog.struct_statement)); + prog.struct_statement_declaration = struct_statement_declaration; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_assignment = /** @class */ (function (_super) { + __extends(struct_statement_assignment, _super); + function struct_statement_assignment(name, value) { + var _this = _super.call(this) || this; + _this.name = name; + _this.value = value; + return _this; + } + return struct_statement_assignment; + }(prog.struct_statement)); + prog.struct_statement_assignment = struct_statement_assignment; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_procedure_call = /** @class */ (function (_super) { + __extends(struct_statement_procedure_call, _super); + function struct_statement_procedure_call(head, arguments_) { + var _this = _super.call(this) || this; + _this.head = head; + _this.arguments = arguments_; + return _this; + } + return struct_statement_procedure_call; + }(prog.struct_statement)); + prog.struct_statement_procedure_call = struct_statement_procedure_call; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_function_definition = /** @class */ (function (_super) { + __extends(struct_statement_function_definition, _super); + function struct_statement_function_definition(name, arguments_, output_type, body, options) { + if (options === void 0) { options = {}; } + var _this = this; + options = Object.assign({ + "async": false + }, options); + _this = _super.call(this) || this; + _this.name = name; + _this.arguments = arguments_; + _this.output_type = output_type; + _this.body = body; + _this.async_ = options.async; + return _this; + } + return struct_statement_function_definition; + }(prog.struct_statement)); + prog.struct_statement_function_definition = struct_statement_function_definition; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_statement_return = /** @class */ (function (_super) { + __extends(struct_statement_return, _super); + function struct_statement_return(expression) { + var _this = _super.call(this) || this; + _this.expression = expression; + return _this; + } + return struct_statement_return; + }(prog.struct_statement)); + prog.struct_statement_return = struct_statement_return; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + /** + */ + var struct_program = /** @class */ (function () { + function struct_program(statements) { + this.statements = statements; + } + return struct_program; + }()); + prog.struct_program = struct_program; + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +/* +This file is part of »bacterio-plankton:prog«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:prog« 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:prog« 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:prog«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var prog; + (function (prog) { + var typescript; + (function (typescript) { + /** + */ + function indentation(active, level) { + return (active + ? "\t".repeat(level) + : ""); + } + /** + */ + function render_type(type, options) { + if (options === void 0) { options = {}; } + options = Object.assign({ + "indent": true, + "level": 0 + }, options); + if (type instanceof prog.struct_type_literal) { + var type_literal = type; + return lib_plankton.string.coin("{{indentation}}{{value}}", { + "indentation": indentation(options.indent, options.level), + "value": render_expression(type_literal.value, { + "level": (options.level + 1) + }) + }); + } + else if (type instanceof prog.struct_type_any) { + var type_any = type; + return lib_plankton.string.coin("{{indentation}}any", { + "indentation": indentation(options.indent, options.level) + }); + } + else if (type instanceof prog.struct_type_void) { + var type_void = type; + return lib_plankton.string.coin("{{indentation}}void", { + "indentation": indentation(options.indent, options.level) + }); + } + else if (type instanceof prog.struct_type_boolean) { + var type_boolean = type; + return lib_plankton.string.coin("{{indentation}}boolean", { + "indentation": indentation(options.indent, options.level) + }); + } + else if (type instanceof prog.struct_type_integer) { + var type_integer = type; + return lib_plankton.string.coin("{{indentation}}number", { + "indentation": indentation(options.indent, options.level) + }); + } + else if (type instanceof prog.struct_type_string) { + var type_string = type; + return lib_plankton.string.coin("{{indentation}}string", { + "indentation": indentation(options.indent, options.level) + }); + } + else if (type instanceof prog.struct_type_list) { + var type_list = type; + return render_type(new prog.struct_type_construction("Array", [ + type_list.element, + ])); + } + else if (type instanceof prog.struct_type_map) { + var type_map = type; + return render_type(new prog.struct_type_construction("Record", [ + type_map.key, + type_map.value, + ])); + } + else if (type instanceof prog.struct_type_record) { + var type_record = type; + return lib_plankton.string.coin("{{indentation1}}{\n{{fields}}\n{{indentation2}}}", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "fields": (type_record.fields + .map(function (field) { return lib_plankton.string.coin("{{indentation}}{{name}} {{assignment}} {{type}}", { + "indentation": indentation(true, options.level + 1), + "name": field.name, + "assignment": (field.mandatory ? ":" : "?:"), + "type": render_type(field.type, { + "indent": false, + "level": (options.level + 1) + }) + }); }) + .join(";\n")) + }); + } + else if (type instanceof prog.struct_type_function) { + var type_function = type; + return lib_plankton.string.coin("{{indentation1}}(({{arguments}})\n{{indentation2}}=>\n{{target}})", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "arguments": (type_function.arguments + .map(function (argument) { return render_type(argument, { + "level": (options.level + 1) + }); }) + .join(", ")), + "target": render_type(type_function.target, { + "level": (options.level + 1) + }) + }); + } + else if (type instanceof prog.struct_type_construction) { + var type_construction = type; + return lib_plankton.string.coin("{{indentation}}{{name}}{{macro_arguments}}", { + "indentation": indentation(options.indent, options.level), + "name": type_construction.name, + "macro_arguments": ((type_construction.arguments === null) + ? "" + : lib_plankton.string.coin("<\n{{arguments}}\n{{indentation}}>", { + "indentation": indentation(true, options.level), + "arguments": (type_construction.arguments + .map(function (argument) { return render_type(argument, { + "level": (options.level + 1) + }); }) + .join(",\n")) + })) + }); + } + else if (type instanceof prog.struct_type_union) { + var type_union = type; + return lib_plankton.string.coin("{{indentation1}}(\n{{left}}\n{{indentation3}}|\n{{right}}\n{{indentation2}})", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "indentation3": indentation(true, options.level + 1), + "left": render_type(type_union.left, { + "level": (options.level + 1) + }), + "right": render_type(type_union.right, { + "level": (options.level + 1) + }) + }); + } + else if (type instanceof prog.struct_type_intersection) { + var type_intersection = type; + return lib_plankton.string.coin("{{indentation1}}(\n{{left}}\n{{indentation2}}&\n{{right}}\n{{indentation2}})", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level + 1), + "left": render_type(type_intersection.left, { + "level": (options.level + 1) + }), + "right": render_type(type_intersection.right, { + "level": (options.level + 1) + }) + }); + } + else { + throw (new Error("unhandled type kind: " + String(type))); + } + } + typescript.render_type = render_type; + /** + */ + function render_expression(expression, options) { + if (options === void 0) { options = {}; } + options = Object.assign({ + "indent": false, + "level": 0 + }, options); + if (expression instanceof prog.struct_expression_variable) { + var expression_variable = expression; + return lib_plankton.string.coin("{{indentation}}{{name}}", { + "indentation": indentation(options.indent, options.level), + "name": expression.name + }); + } + else if (expression instanceof prog.struct_expression_literal) { + var expression_literal = expression; + return lib_plankton.string.coin("{{indentation}}{{value}}", { + "indentation": indentation(options.indent, options.level), + "value": JSON.stringify(expression_literal.value) + }); + } + else if (expression instanceof prog.struct_expression_list) { + var expression_list = expression; + return lib_plankton.string.coin("{{indentation1}}[\n{{elements}}\n{{indentation2}}]", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "elements": (expression_list.elements + .map(function (element) { return lib_plankton.string.coin("{{indentation}}{{value}}", { + "indentation": indentation(true, options.level + 1), + "value": render_expression(element, { + "indent": false, + "level": (options.level + 1) + }) + }); }) + .join(",\n")) + }); + } + else if (expression instanceof prog.struct_expression_dict) { + var expression_dict = expression; + return lib_plankton.string.coin("{{indentation1}}{\n{{fields}}\n{{indentation2}}}", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "fields": (expression_dict.fields + .map(function (field) { return lib_plankton.string.coin("{{indentation}}\"{{key}}\": {{value}}", { + "indentation": indentation(true, options.level + 1), + "key": field.key, + "value": render_expression(field.value, { + "indent": false, + "level": (options.level + 1) + }) + }); }) + .join(",\n")) + }); + } + else if (expression instanceof prog.struct_expression_abstraction) { + var expression_abstraction = expression; + return lib_plankton.string.coin("{{indentation1}}{{macro_async}}function ({{arguments}}){{macro_output_type}} {\n{{body}}{{indentation2}}}", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "macro_async": (expression_abstraction.async_ + ? "async " + : ""), + "arguments": (expression_abstraction.arguments + .map(function (argument) { return lib_plankton.string.coin("{{name}}{{macro_type}}", { + "name": argument.name, + "macro_type": ((argument.type === null) + ? "" + : lib_plankton.string.coin(" : {{type}}", { + "type": render_type(argument.type) + })) + }); }) + .join(", ")), + "macro_output_type": ((expression_abstraction.output_type === null) + ? "" + : lib_plankton.string.coin(" : {{type}}", { + "type": render_type(expression_abstraction.output_type, { + "indent": false, + "level": (options.level + 1) + }) + })), + "body": (expression_abstraction.body + .map(function (statement) { return render_statement(statement, { + "level": (options.level + 1) + }); }) + .join("")) + }); + } + else if (expression instanceof prog.struct_expression_function_application) { + var expression_function_application = expression; + return lib_plankton.string.coin("{{indentation1}}{{name}}(\n{{arguments}}\n{{indentation2}})", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "name": render_expression(expression_function_application.head, { + "indent": false, + "level": (options.level + 0) + }), + "arguments": (expression_function_application.arguments + .map(function (argument) { return lib_plankton.string.coin("{{argument}}", { + "argument": render_expression(argument, { + "indent": true, + "level": (options.level + 1) + }) + }); }) + .join(",\n")) + }); + } + else if (expression instanceof prog.struct_expression_projection) { + var expression_projection = expression; + return lib_plankton.string.coin("{{indentation}}{{source}}[{{index}}]", { + "indentation": indentation(options.indent, options.level), + "source": render_expression(expression_projection.source), + "index": render_expression(expression_projection.index) + }); + } + else if (expression instanceof prog.struct_expression_fieldaccess) { + var expression_fieldaccess = expression; + return lib_plankton.string.coin("{{indentation}}{{structure}}.{{fieldname}}", { + "indentation": indentation(options.indent, options.level), + "structure": render_expression(expression_fieldaccess.structure, { + "level": (options.level + 1) + }), + "fieldname": expression_fieldaccess.fieldname + }); + } + else if (expression instanceof prog.struct_expression_operation_comparison) { + var expression_operation_comparison = expression; + return lib_plankton.string.coin("{{indentation}}({{left}} === {{right}})", { + "indentation": indentation(options.indent, options.level), + "left": render_expression(expression_operation_comparison.left, { + "indent": false, + "level": (options.level + 0) + }), + "right": render_expression(expression_operation_comparison.right, { + "indent": false, + "level": (options.level + 0) + }) + }); + } + else if (expression instanceof prog.struct_expression_await) { + var expression_await = expression; + return lib_plankton.string.coin("{{indentation}}await {{target}}", { + "indentation": indentation(options.indent, options.level), + "target": render_expression(expression_await.target, { + "indent": false, + "level": (options.level + 0) + }) + }); + } + else if (expression instanceof prog.struct_expression_cast) { + var expression_cast = expression; + return lib_plankton.string.coin("{{indentation}}({{expression}} as {{type}})", { + "indentation": indentation(options.indent, options.level), + "expression": render_expression(expression_cast.expression, { + "indent": false, + "level": (options.level + 0) + }), + "type": render_type(expression_cast.type, { + "indent": false, + "level": (options.level + 0) + }) + }); + } + else { + throw (new Error("unhandled expression: " + String(expression))); + } + } + typescript.render_expression = render_expression; + /** + */ + function render_statement(statement, options) { + if (options === void 0) { options = {}; } + options = Object.assign({ + "indent": true, + "level": 0 + }, options); + if (statement instanceof prog.struct_statement_comment) { + var statement_comment = statement; + return (statement_comment.block + ? lib_plankton.string.coin("{{indentation}}/**\n{{lines}}{{indentation}} */\n", { + "indentation": indentation(options.indent, options.level), + "lines": (statement_comment.lines + .map(function (line) { return lib_plankton.string.coin("{{indentation}} * {{line}}\n", { + "indentation": indentation(options.indent, options.level), + "line": line + }); }) + .join("")) + }) + : lib_plankton.string.coin("{{lines}}", { + "lines": (statement_comment.lines + .map(function (line) { return lib_plankton.string.coin("{{indentation}}// {{line}}\n", { + "indentation": indentation(options.indent, options.level), + "line": line + }); }) + .join("")) + })); + } + else if (statement instanceof prog.struct_statement_block) { + var statement_block = statement; + return lib_plankton.string.coin("{{indentation}}{\n{{statements}}{{indentation}}}\n", { + "indentation": indentation(options.indent, options.level), + "statements": (statement_block.statements + .map(function (statement) { return render_statement(statement, { + "level": (options.level + 1) + }); }) + .join("")) + }); + } + else if (statement instanceof prog.struct_statement_type_definition) { + var statement_type_definition = statement; + return lib_plankton.string.coin("{{indentation}}{{macro_export}}type {{name}} = {{type}};\n", { + "indentation": indentation(options.indent, options.level), + "name": statement_type_definition.name, + "macro_export": ((!statement_type_definition.export_) + ? "" + : "export "), + "type": render_type(statement_type_definition.type, { + "indent": false, + "level": (options.level + 0) + }) + }); + } + else if (statement instanceof prog.struct_statement_declaration) { + var statement_declaration = statement; + return lib_plankton.string.coin("{{indentation}}{{macro_export}}{{kind}} {{name}}{{macro_type}}{{macro_value}};\n", { + "indentation": indentation(options.indent, options.level), + "kind": (statement_declaration.constant + ? "const" + : "let"), + "name": statement_declaration.name, + "macro_export": ((!statement_declaration.export_) + ? "" + : "export "), + "macro_type": ((statement_declaration.type === null) + ? "" + : lib_plankton.string.coin(" : {{type}}", { + "type": render_type(statement_declaration.type, { + "indent": false, + "level": (options.level + 0) + }) + })), + "macro_value": ((statement_declaration.value === null) + ? "" + : lib_plankton.string.coin(" = {{value}}", { + "value": render_expression(statement_declaration.value, { + "indent": false, + "level": (options.level + 0) + }) + })) + }); + } + else if (statement instanceof prog.struct_statement_assignment) { + var statement_assignment = statement; + return lib_plankton.string.coin("{{indentation}}{{name}} = {{value}};\n", { + "indentation": indentation(options.indent, options.level), + "name": statement_assignment.name, + "value": render_expression(statement_assignment.value, { + "indent": false, + "level": (options.level + 1) + }) + }); + } + else if (statement instanceof prog.struct_statement_procedure_call) { + var statement_procedure_call = statement; + return lib_plankton.string.coin("{{indentation1}}{{name}}(\n{{arguments}}\n{{indentation2}});\n", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "name": render_expression(statement_procedure_call.head, { + "indent": false, + "level": (options.level + 0) + }), + "arguments": (statement_procedure_call.arguments + .map(function (argument) { return lib_plankton.string.coin("{{argument}}", { + "argument": render_expression(argument, { + "indent": true, + "level": (options.level + 1) + }) + }); }) + .join(",\n")) + }); + } + else if (statement instanceof prog.struct_statement_function_definition) { + var statement_function_definition = statement; + return lib_plankton.string.coin("{{indentation1}}{{macro_async}}function {{name}}(\n{{arguments}}\n{{indentation2}}){{macro_output_type}}\n{{indentation2}}{\n{{body}}{{indentation2}}}\n", { + "indentation1": indentation(options.indent, options.level), + "indentation2": indentation(true, options.level), + "macro_async": (statement_function_definition.async_ + ? "async " + : ""), + "name": statement_function_definition.name, + "arguments": (statement_function_definition.arguments + .map(function (argument) { return lib_plankton.string.coin("{{indentation}}{{name}}{{macro_type}}", { + "indentation": indentation(true, (options.level + 1)), + "name": argument.name, + "macro_type": ((argument.type === null) + ? "" + : lib_plankton.string.coin(" : {{type}}", { + "type": render_type(argument.type, { + "indent": false, + "level": (options.level + 2) + }) + })) + }); }) + .join(",\n")), + "macro_output_type": ((statement_function_definition.output_type === null) + ? "" + : lib_plankton.string.coin(" : {{type}}", { + "type": render_type(statement_function_definition.output_type, { + "indent": false, + "level": (options.level + 0) + }) + })), + "body": (statement_function_definition.body + .map(function (statement) { return render_statement(statement, { + "indent": true, + "level": (options.level + 1) + }); }) + .join("")) + }); + } + else if (statement instanceof prog.struct_statement_return) { + var statement_return = statement; + return lib_plankton.string.coin("{{indentation}}return {{expression}};\n", { + "indentation": indentation(options.indent, options.level), + "expression": render_expression(statement_return.expression, { + "indent": false, + "level": (options.level + 0) + }) + }); + } + else { + throw (new Error("unhandled statement: " + (statement.constructor.name))); + } + } + typescript.render_statement = render_statement; + /** + */ + function render_program(program) { + return (program.statements + .map(function (statement) { return render_statement(statement, { + "indent": true, + "level": 0 + }); }) + .join("\n")); + } + typescript.render_program = render_program; + /** + */ + function output_typescript() { + return { + "render_expression": render_expression, + "render_type": render_type, + "render_statement": render_statement, + "render_program": render_program + }; + } + typescript.output_typescript = output_typescript; + })(typescript = prog.typescript || (prog.typescript = {})); + })(prog = lib_plankton.prog || (lib_plankton.prog = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:args«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:args« 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:args« 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:args«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var args; + (function (args) { + /** + */ + var enum_environment; + (function (enum_environment) { + enum_environment["cli"] = "cli"; + enum_environment["url"] = "url"; + })(enum_environment = args.enum_environment || (args.enum_environment = {})); + ; + /** + */ + var enum_kind; + (function (enum_kind) { + enum_kind["positional"] = "positional"; + enum_kind["volatile"] = "volatile"; + })(enum_kind = args.enum_kind || (args.enum_kind = {})); + ; + /** + */ + var enum_type; + (function (enum_type) { + enum_type["boolean"] = "boolean"; + enum_type["integer"] = "int"; + enum_type["float"] = "float"; + enum_type["string"] = "string"; + })(enum_type = args.enum_type || (args.enum_type = {})); + ; + /** + */ + var enum_mode; + (function (enum_mode) { + enum_mode["replace"] = "replace"; + enum_mode["accumulate"] = "accumulate"; + })(enum_mode = args.enum_mode || (args.enum_mode = {})); + ; + })(args = lib_plankton.args || (lib_plankton.args = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:args«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:args« 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:args« 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:args«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var args; + (function (args) { + /* + export enum_mode { + replace = "replace", + accumulate = "accumulate", + }; + */ + /** + * @author fenris + */ + var class_argument = /** @class */ (function () { + /** + * @author fenris + */ + function class_argument(_a) { + var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["kind"], kind = _c === void 0 ? args.enum_kind.positional : _c, _d = _a["mode"], mode = _d === void 0 ? args.enum_mode.replace : _d, _e = _a["default"], default_ = _e === void 0 ? null : _e, _f = _a["info"], info = _f === void 0 ? null : _f, _g = _a["parameters"], parameters = _g === void 0 ? {} : _g, _h = _a["hidden"], hidden = _h === void 0 ? false : _h; + this.name = name; + this.type = type; + this.kind = kind; + this.mode = mode; + this.default_ = default_; + this.info = info; + this.parameters = parameters; + this.hidden = hidden; + if (!this.check()) { + throw (new Error("invalid argument-setup")); + } + } + /** + * @author fenris + */ + class_argument.positional = function (_a) { + var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, index = _a["index"]; + return (new class_argument({ + "name": name, + "kind": args.enum_kind.positional, + "type": type, + "mode": mode, + "default": default_, + "info": info, + "hidden": hidden, + "parameters": { + "index": index + } + })); + }; + /** + * @author fenris + */ + class_argument.volatile = function (_a) { + var name = _a["name"], _b = _a["type"], type = _b === void 0 ? args.enum_type.string : _b, _c = _a["mode"], mode = _c === void 0 ? args.enum_mode.replace : _c, _d = _a["default"], default_ = _d === void 0 ? null : _d, _e = _a["info"], info = _e === void 0 ? null : _e, _f = _a["hidden"], hidden = _f === void 0 ? false : _f, indicators_short = _a["indicators_short"], indicators_long = _a["indicators_long"]; + return (new class_argument({ + "name": name, + "kind": args.enum_kind.volatile, + "type": type, + "mode": mode, + "default": default_, + "info": info, + "hidden": hidden, + "parameters": { + "indicators_short": indicators_short, + "indicators_long": indicators_long + } + })); + }; + /** + * @author fenris + */ + class_argument.prototype.check = function () { + var _this = this; + return [ + function () { return ((!(_this.kind == args.enum_kind.volatile)) + || + (("indicators_long" in _this.parameters) + && + (_this.parameters["indicators_long"]["length"] >= 0))); }, + ].every(function (condition) { return condition(); }); + }; + /** + * @author fenris + */ + class_argument.prototype.name_get = function () { + return this.name; + }; + /** + * @author fenris + */ + class_argument.prototype.kind_get = function () { + return this.kind; + }; + /** + * @author fenris + */ + class_argument.prototype.type_get = function () { + return this.type; + }; + /** + * @author fenris + */ + class_argument.prototype.mode_get = function () { + return this.mode; + }; + /** + * @author fenris + */ + class_argument.prototype.default_get = function () { + return this.default_; + }; + /** + * @author fenris + */ + class_argument.prototype.parameters_get = function () { + return this.parameters; + }; + /** + * @author fenris + */ + class_argument.prototype.hidden_get = function () { + return this.hidden; + }; + /** + * @author fenris + */ + class_argument.prototype.toString = function () { + return "<".concat(this.name, ">"); + }; + /** + * @author fenris + */ + class_argument.prototype.indicator_main = function () { + if (this.kind === args.enum_kind.volatile) { + return this.parameters["indicators_long"][0]; + } + else { + return null; + } + }; + /** + * @author fenris + */ + class_argument.prototype.pattern_value = function () { + switch (this.type) { + case args.enum_type.boolean: { + return "false|true"; + break; + } + case args.enum_type.integer: { + return "[0-9]+"; + break; + } + case args.enum_type.float: { + return "\\d*(?:\\.\\d+)?"; + break; + } + case args.enum_type.string: { + return "\\S+"; + break; + } + default: { + throw (new Error("unhandled type ".concat(this.type))); + break; + } + } + }; + /** + * @author fenris + */ + class_argument.prototype.extract = function (raw) { + switch (this.type) { + case args.enum_type.boolean: { + return (raw != "false"); + break; + } + case args.enum_type.integer: { + return parseInt(raw); + break; + } + case args.enum_type.float: { + return parseFloat(raw); + break; + } + case args.enum_type.string: { + return raw; + break; + } + default: { + throw (new Error("unhandled type ".concat(this.type))); + break; + } + } + }; + /** + * @author fenris + */ + class_argument.prototype.assign = function (data, target, raw) { + var value = this.extract(raw); + switch (this.mode) { + case args.enum_mode.replace: { + data[target] = value; + break; + } + case args.enum_mode.accumulate: { + /* + if (! (this.name in data)) { + data[this.name] = []; + } + */ + data[target].push(value); + break; + } + default: { + throw (new Error("unhandled mode ".concat(this.mode))); + } + } + }; + /** + * @author fenris + */ + class_argument.prototype.make = function (data, target) { + var value = data[target]; + return value.toString(); + }; + /** + * @author fenris + */ + class_argument.prototype.generate_help = function () { + var _this = this; + var _a, _b, _c, _d; + var output = ""; + { + switch (this.kind) { + case args.enum_kind.positional: { + var line = ""; + line += "\t"; + line += "<".concat(this.name, ">"); + line += "\n"; + output += line; + } + case args.enum_kind.volatile: { + var line = ""; + line += "\t"; + if (this.type === args.enum_type.boolean) { + line += ([] + .concat(((_a = this.parameters["indicators_short"]) !== null && _a !== void 0 ? _a : []).map(function (indicator) { return ("-" + indicator); })) + .concat(((_b = this.parameters["indicators_long"]) !== null && _b !== void 0 ? _b : []).map(function (indicator) { return ("--" + indicator); })) + .join(" | ")); + } + else { + line += ([] + .concat(((_c = this.parameters["indicators_short"]) !== null && _c !== void 0 ? _c : []).map(function (indicator) { return ("-" + indicator + " " + ("<" + _this.name + ">")); })) + .concat(((_d = this.parameters["indicators_long"]) !== null && _d !== void 0 ? _d : []).map(function (indicator) { return ("--" + indicator + "=" + ("<" + _this.name + ">")); })) + .join(" | ")); + } + line += "\n"; + output += line; + } + } + } + { + var line = ""; + line += "\t\t"; + var infotext = ((this.info == null) ? "(no info available)" : this.info); + line += infotext; + if ((this.type != "boolean") && (this.default_ != null)) { + line += "; default: ".concat(this.default_.toString()); + } + line += "\n"; + output += line; + } + return output; + }; + return class_argument; + }()); + args.class_argument = class_argument; + })(args = lib_plankton.args || (lib_plankton.args = {})); +})(lib_plankton || (lib_plankton = {})); +/* +This file is part of »bacterio-plankton:args«. + +Copyright 2016-2024 'Christian Fraß, Christian Neubauer, Martin Springwald GbR' + + +»bacterio-plankton:args« 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:args« 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:args«. If not, see . + */ +var lib_plankton; +(function (lib_plankton) { + var args; + (function (args) { + /** + * @author fenris + */ + var settings = { + "environment": { + "cli": { + "symbols": { + "delimiter": " ", + "prefix": "--", + "assignment": "=" + } + }, + "url": { + "symbols": { + "delimiter": "&", + "prefix": "", + "assignment": "=" + } + } + } + }; + /** + * @author fenris + */ + args.verbosity = 0; + /** + * @author fenris + * @todo check validity + */ + var class_handler = /** @class */ (function () { + /** + * @author fenris + */ + function class_handler(arguments_) { + this.arguments_ = arguments_; + } + /** + * @author fenris + */ + class_handler.prototype.filter = function (kind) { + var arguments_ = {}; + for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) { + var _b = _a[_i], name = _b[0], argument = _b[1]; + if (argument.kind_get() == kind) { + arguments_[name] = argument; + } + } + return arguments_; + }; + /** + * @author fenris + */ + class_handler.prototype.read = function (environment, input, data) { + var _this = this; + if (data === void 0) { data = {}; } + switch (environment) { + case args.enum_environment.cli: + case args.enum_environment.url: { + // default values + { + for (var _i = 0, _a = Object.entries(this.arguments_); _i < _a.length; _i++) { + var _b = _a[_i], name = _b[0], argument = _b[1]; + data[name] = argument.default_get(); + } + } + // preprocessing + { + // short indicators (lil hacky ...) + { + if (environment == args.enum_environment.cli) { + for (var _c = 0, _d = Object.entries(this.filter(args.enum_kind.volatile)); _c < _d.length; _c++) { + var _e = _d[_c], name = _e[0], argument = _e[1]; + // console.info(argument.parameters_get()["indicators_short"].join("|")); + var pattern_from = ""; + { + pattern_from += "(?:^|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")"); + pattern_from += "-".concat(argument.parameters_get()["indicators_short"].join("|")); + pattern_from += "(?:$|".concat(settings["environment"][environment]["symbols"]["delimiter"], ")"); + } + var pattern_to = ""; + { + pattern_to += settings["environment"][environment]["symbols"]["delimiter"]; + pattern_to += settings["environment"][environment]["symbols"]["prefix"]; + pattern_to += argument.indicator_main(); + if (argument.type_get() == args.enum_type.boolean) { + pattern_to += settings["environment"][environment]["symbols"]["delimiter"]; + } + else { + pattern_to += settings["environment"][environment]["symbols"]["assignment"]; + } + } + var result = input.replace(new RegExp(pattern_from, "g"), pattern_to); + lib_plankton.log.debug("lib_args:read:replacing", { + "pattern_from": pattern_from, + "pattern_to": pattern_to, + "input": input, + "result": result + }); + input = result; + } + } + } + lib_plankton.log.debug("lib_args:read:current_input", { + "input": input + }); + } + // parsing + { + var parts = input + .split(settings["environment"][environment]["symbols"]["delimiter"]) + .filter(function (x) { return (x != ""); }); + var index_expected_1 = 0; + parts.forEach(function (part) { + lib_plankton.log.debug("lib_args:read:analyzing", { + "part": part + }); + var found = [ + function () { + lib_plankton.log.debug("lib_args:read:probing_as_volatile", { + "part": part + }); + for (var _i = 0, _a = Object.entries(_this.filter(args.enum_kind.volatile)); _i < _a.length; _i++) { + var _b = _a[_i], name = _b[0], argument = _b[1]; + lib_plankton.log.debug("lib_args:read:probing_as_volatile:trying", { + "part": part, + "argument": argument.toString() + }); + var pattern = ""; + { + var pattern_front = ""; + pattern_front += "".concat(settings["environment"][environment]["symbols"]["prefix"]); + pattern_front += "(?:".concat(argument.parameters_get()["indicators_long"].join("|"), ")"); + pattern += pattern_front; + } + { + var pattern_back = ""; + pattern_back += "".concat(settings["environment"][environment]["symbols"]["assignment"]); + pattern_back += "(".concat(argument.pattern_value(), ")"); + if (argument.type_get() == args.enum_type.boolean) { + pattern_back = "(?:".concat(pattern_back, ")?"); + } + pattern += pattern_back; + } + lib_plankton.log.debug("lib_args:read:probing_as_volatile:pattern", { + "pattern": pattern + }); + var regexp = new RegExp(pattern); + var matching = regexp.exec(part); + lib_plankton.log.debug("lib_args:read:probing_as_volatile:matching", { + "matching": matching + }); + if (matching == null) { + // do nothing + } + else { + argument.assign(data, name, matching[1]); + return true; + } + } + return false; + }, + function () { + lib_plankton.log.debug("lib_args:read:probing_as_positional", { + "part": part + }); + var positional = _this.filter(args.enum_kind.positional); + for (var _i = 0, _a = Object.entries(positional); _i < _a.length; _i++) { + var _b = _a[_i], name = _b[0], argument = _b[1]; + if (argument.parameters_get()['index'] !== index_expected_1) { + // do nothing + } + else { + lib_plankton.log.debug("lib_args:read:probing_as_positional:trying", { + "part": part, + "argument": argument.toString() + }); + var pattern = ""; + { + var pattern_back = ""; + pattern_back += "(".concat(argument.pattern_value(), ")"); + pattern += pattern_back; + } + lib_plankton.log.debug("lib_args:read:probing_as_positional:pattern", { + "pattern": pattern + }); + var regexp = new RegExp(pattern); + var matching = regexp.exec(part); + lib_plankton.log.debug("lib_args:read:probing_as_positional:matching", { + "matching": matching + }); + if (matching == null) { + return false; + } + else { + argument.assign(data, name, matching[1]); + index_expected_1 += 1; + return true; + } + } + } + return false; + }, + ].some(function (x) { return x(); }); + if (!found) { + lib_plankton.log.warning("lib_args:read:could_not_parse", { + "part": part + }); + } + }); + } + return data; + break; + } + default: { + throw (new Error("unhandled environment ".concat(environment))); + break; + } + } + }; + /** + * @author fenris + * @todo handle if the data object doesn't have the required field or the type is wrong or sth. + */ + class_handler.prototype.write = function (environment, data) { + switch (environment) { + case args.enum_environment.cli: { + return (([] + .concat(Object.entries(this.filter(args.enum_kind.volatile)).map(function (_a) { + var name = _a[0], argument = _a[1]; + var values; + switch (argument.mode_get()) { + case args.enum_mode.replace: { + values = [data[argument.name_get()]]; + break; + } + case args.enum_mode.accumulate: { + values = data[argument.name_get()]; + break; + } + } + return (values + .map(function (value) { return ((settings["environment"][environment]["symbols"]["prefix"] + + + argument.parameters_get()["indicators_long"][0]) + + + (settings["environment"][environment]["symbols"]["assignment"] + + + value.toString())); }) + .join(" ")); + })) + .concat(Object.entries(this.filter(args.enum_kind.positional)).map(function (_a) { + var name = _a[0], argument = _a[1]; + var raw = ""; + { + var raw_back = ""; + raw_back += argument.make(data, name); + raw += raw_back; + } + return raw; + }))) + .join(settings["environment"][environment]["symbols"]["delimiter"])); + break; + } + default: { + throw (new Error("unhandled environment ".concat(environment))); + break; + } + } + }; + /** + * @desc manpage-like info-sheet + * @author fenris + */ + class_handler.prototype.generate_help = function (_a) { + var _b = _a["programname"], programname = _b === void 0 ? null : _b, _c = _a["author"], author = _c === void 0 ? null : _c, _d = _a["description"], description = _d === void 0 ? null : _d, _e = _a["executable"], executable = _e === void 0 ? null : _e; + var environment = args.enum_environment.cli; + var output = ""; + { + var section = ""; + { + var line = ""; + line += ""; + line += "INFO"; + line += "\n"; + section += line; + } + { + var line = ""; + line += "\t"; + line += "".concat(programname, " -- ").concat(description); + line += "\n"; + section += line; + } + section += "\n"; + output += section; + } + { + if (author != null) { + var section = ""; + { + var line = ""; + line += ""; + line += "AUTHOR"; + line += "\n"; + section += line; + } + { + var line = ""; + line += "\t"; + line += "".concat(author); + line += "\n"; + section += line; + } + section += "\n"; + output += section; + } + } + { + var section = ""; + { + var line = ""; + line += ""; + line += "SYNOPSIS"; + line += "\n"; + section += line; + } + { + var line = ""; + line += "\t"; + line += executable; + line += settings["environment"][environment]["symbols"]["delimiter"]; + line += Object.entries(this.filter(args.enum_kind.positional)) + .map(function (_a) { + var name = _a[0], argument = _a[1]; + var part = ""; + part += "<".concat(argument.name_get(), ">"); + return part; + }) + .join(settings["environment"][environment]["symbols"]["delimiter"]); + line += settings["environment"][environment]["symbols"]["delimiter"]; + line += Object.entries(this.filter(args.enum_kind.volatile)) + .filter(function (_a) { + var name = _a[0], argument = _a[1]; + return (!argument.hidden_get()); + }) + .map(function (_a) { + var name = _a[0], argument = _a[1]; + var part = ""; + // part += settings["environment"][environment]["symbols"]["prefix"]; + part += "-"; + part += argument.parameters_get()["indicators_short"][0]; + if (argument.type_get() != "boolean") { + /* + part += settings["environment"][environment]["symbols"]["assignment"]; + part += `<${argument.name_get()}>`; + */ + part += " "; + part += "<".concat(argument.name_get(), ">"); + } + part = "[".concat(part, "]"); + return part; + }) + .join(settings["environment"][environment]["symbols"]["delimiter"]); + line += "\n"; + section += line; + } + section += "\n"; + output += section; + } + { + var section = ""; + { + var line = ""; + line += ""; + line += "OPTIONS"; + line += "\n"; + section += line; + } + { + section += (Object.entries(this.arguments_) + .filter(function (_a) { + var name = _a[0], argument = _a[1]; + return (!argument.hidden_get()); + }) + .map(function (_a) { + var name = _a[0], argument = _a[1]; + return argument.generate_help(); + }) + .join("\n")); + } + section += "\n"; + output += section; + } + return output; + }; + return class_handler; + }()); + args.class_handler = class_handler; + })(args = lib_plankton.args || (lib_plankton.args = {})); +})(lib_plankton || (lib_plankton = {})); diff --git a/readme.md b/readme.md new file mode 100644 index 0000000..949a7c0 --- /dev/null +++ b/readme.md @@ -0,0 +1,94 @@ +# sindri + +erstellt Datenmodell-Skripte in verschiedenen Ausgabe-Sprachen (MySQL, SQLite, …) auf Basis einer abstrakten Beschreibung + + +## Erstellung + +### Voraussetzungen + +- Typescript-Compiler +- GNU Make + + +### Anweisungen + +- `tools/build` ausführen + + +## Dokumentation + +Beispiel-Nutzung: + +```sh +tools/build +cd build + +cat ../doc/examples/contacts.sindri.json | ./sindri -f database:sqlite +``` + +… erzeugt: + +```sql +CREATE TABLE + `address`( + `id` INTEGER PRIMARY KEY AUTOINCREMENT, + `city` VARCHAR(255) NOT NULL, + `zip` VARCHAR(255) NOT NULL, + `street` VARCHAR(255) NOT NULL + ) +; + +CREATE TABLE + `person`( + `id` INTEGER PRIMARY KEY AUTOINCREMENT, + `prename` VARCHAR(255) NOT NULL, + `surname` VARCHAR(255) NOT NULL, + `address_id` INTEGER NOT NULL, + `email_address` VARCHAR(255) DEFAULT NULL + ) +; +``` + +Der Befehl muss nur minimal gewändert werden um die PostgreSQL-Ausgabe zu erhalten: + +```sh +cat ../doc/examples/contacts.sindri.json | ./sindri -f database:postgresql +``` + +… erzeugt: + +```sql +CREATE TABLE + address( + "id" SERIAL, + "city" VARCHAR(255) NOT NULL, + "zip" VARCHAR(255) NOT NULL, + "street" VARCHAR(255) NOT NULL, + UNIQUE ("id") + ) +; +COMMENT ON TABLE address IS 'collection of addresses'; +COMMENT ON COLUMN address.city IS 'the name of the city'; +COMMENT ON COLUMN address.zip IS 'the postal code'; +COMMENT ON COLUMN address.street IS 'the name of the street and the house number'; + +CREATE TABLE + person( + "id" SERIAL, + "prename" VARCHAR(255) NOT NULL, + "surname" VARCHAR(255) NOT NULL, + "address_id" INTEGER NOT NULL, + "email_address" VARCHAR(255) DEFAULT NULL, + UNIQUE ("id") + ) +; +COMMENT ON TABLE person IS 'collection of contacts'; +COMMENT ON COLUMN person.prename IS 'first name of the person'; +COMMENT ON COLUMN person.surname IS 'last name of the person'; +COMMENT ON COLUMN person.address_id IS 'reference to the associated address dataset'; +COMMENT ON COLUMN person.email_address IS 'optional eMail address'; +``` + + + diff --git a/source/base.ts b/source/base.ts new file mode 100644 index 0000000..560bc1a --- /dev/null +++ b/source/base.ts @@ -0,0 +1,127 @@ +declare var __dirname; + +namespace _sindri +{ + + /** + */ + export type type_input = { + domains : Array< + { + name : string; + description : (null | string); + key_field : ( + null + | + { + name : string; + description ?: (null | string); + } + ); + data_fields : Array< + { + name : string; + description : (null | string); + type : ("boolean" | "integer" | "float" | "string_short" | "string_medium" | "string_long"); + nullable : boolean; + default : (null | boolean | int | float | string); + } + >; + constraints ?: Array< + { + kind : ("unique" | "foreign_key"); + parameters : Record; + } + >; + } + >; + }; + + + /** + */ + export type type_output = { + render : ((input_data : type_input) => Promise); + }; + + + /** + */ + export enum enum_realm { + database = "database", + backend = "backend", + frontend = "frontend", + other = "other", + } + + + /** + */ + var _outputs : Record> = { + [enum_realm.database]: {}, + [enum_realm.backend]: {}, + [enum_realm.frontend]: {}, + [enum_realm.other]: {}, + }; + + + /** + */ + export function add_output( + realm : enum_realm, + implementation : string, + output : _sindri.type_output + ) : void + { + _outputs[realm][implementation] = output; + } + + + /** + */ + export function get_output( + realm : enum_realm, + implementation : string + ) : _sindri.type_output + { + return _outputs[realm][implementation]; + } + + + /** + */ + export function list_outputs( + ) : Array<{realm : enum_realm; implementation : string;}> + { + return ( + Object.entries(_outputs) + .map( + ([realm, group]) => ( + Object.keys(group) + .map( + implementation => ({"realm": (realm as enum_realm), "implementation": implementation}) + ) + ) + ) + .reduce( + (x, y) => x.concat(y), + [] + ) + ); + } + + + /** + */ + export function get_template( + realm : enum_realm, + implementation : string, + name : string + ) : Promise + { + return lib_plankton.file.read( + [__dirname, "templates", realm, implementation, name].join("/") + ); + } + +} diff --git a/source/conf.ts b/source/conf.ts new file mode 100644 index 0000000..b7d4215 --- /dev/null +++ b/source/conf.ts @@ -0,0 +1,189 @@ +namespace _sindri +{ + + /** + * @todo generate generic + */ + export function input_schema( + ) : any + { + return { + "type": "object", + "additionalProperties": false, + "properties": { + "domains": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": ["null", "string"], + "default": null + }, + "key_field": { + "type": ["null","object"], + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": ["null", "string"], + "default": null + } + }, + "required": [ + "name" + ], + "default": null + }, + "data_fields": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": false, + "properties": { + "name": { + "type": "string" + }, + "description": { + "type": ["null", "string"], + "default": null + }, + "type": { + "type": "string", + "enum": [ + "boolean", + "integer", + "float", + "string_short", + "string_medium", + "string_long" + ] + }, + "nullable": { + "type": "boolean", + "default": true + }, + "default": { + "type": ["null", "boolean", "integer", "float", "string"], + "default": null + } + }, + "required": [ + "name", + "type" + ] + }, + "default": [] + }, + "constraints": { + "type": "array", + "items": { + "type": "object", + "additionalProperties": false, + "properties": { + "kind": { + "type": "string", + "enum": [ + "unique", + "foreign_key" + ] + }, + "parameters": { + "type": "object", + "additionalProperties": "string", + "properties": { + }, + "required": [ + ] + } + }, + "required": [ + "kind" + ] + }, + "default": [] + } + }, + "required": [ + "name" + ] + } + } + }, + "required": [ + "domains" + ] + } + } + + + /** + */ + export function input_normalize( + input_raw : any + ) : type_input + { + // validate + if (! input_raw.hasOwnProperty("domains")) { + throw (new Error("input node is missing mandatory field 'domains'")); + } + else { + // sanitize + return { + "domains": ( + input_raw["domains"] + .map( + domain_raw => ({ + "name": domain_raw["name"], + "description": (domain_raw["description"] ?? null), + "key_field": ( + (domain_raw.hasOwnProperty("key_field") && (domain_raw["key_field"] !== null)) + ? { + "name": domain_raw["key_field"]["name"], + "description": (domain_raw["key_field"]["description"] ?? null), + } + : null + ), + "data_fields": ( + (domain_raw.hasOwnProperty("data_fields") && (domain_raw["data_fields"] !== null)) + ? ( + domain_raw["data_fields"] + .map( + data_field_raw => ({ + "name": data_field_raw["name"], + "description": (data_field_raw["description"] ?? null), + "type": data_field_raw["type"], + "nullable": (data_field_raw["nullable"] ?? true), + "default": data_field_raw["default"], + }) + ) + ) + : [] + ), + "constraints": ( + (domain_raw.hasOwnProperty("constraints") && (domain_raw["constraints"] !== null)) + ? ( + domain_raw["constraints"] + .map( + constraint_raw => ({ + "kind": constraint_raw["kind"], + "parameters": (constraint_raw["parameters"] ?? {}), + }) + ) + ) + : [] + ), + }) + ) + ), + }; + } + } + +} diff --git a/source/main.ts b/source/main.ts new file mode 100644 index 0000000..ebba866 --- /dev/null +++ b/source/main.ts @@ -0,0 +1,135 @@ +namespace _sindri +{ + + /** + */ + export async function main( + args_raw : Array + ) : Promise + { + const arg_handler = new lib_plankton.args.class_handler( + { + "format": new lib_plankton.args.class_argument({ + "name": "format", + "type": lib_plankton.args.enum_type.string, + "kind": lib_plankton.args.enum_kind.volatile, + "mode": lib_plankton.args.enum_mode.replace, + "default": "database:sqlite", + "parameters": { + "indicators_long": ["format"], + "indicators_short": ["f"], + }, + "info": "output format", + }), + "list": new lib_plankton.args.class_argument({ + "name": "list", + "type": lib_plankton.args.enum_type.boolean, + "kind": lib_plankton.args.enum_kind.volatile, + "mode": lib_plankton.args.enum_mode.replace, + "default": false, + "parameters": { + "indicators_long": ["list"], + "indicators_short": ["l"], + }, + "info": "list available output formats", + }), + "schema": new lib_plankton.args.class_argument({ + "name": "schema", + "type": lib_plankton.args.enum_type.boolean, + "kind": lib_plankton.args.enum_kind.volatile, + "mode": lib_plankton.args.enum_mode.replace, + "default": false, + "parameters": { + "indicators_long": ["schema"], + "indicators_short": ["s"], + }, + "info": "print sindri JSON schema to stdout and exit", + }), + "help": new lib_plankton.args.class_argument({ + "name": "help", + "type": lib_plankton.args.enum_type.boolean, + "kind": lib_plankton.args.enum_kind.volatile, + "mode": lib_plankton.args.enum_mode.replace, + "default": false, + "parameters": { + "indicators_long": ["help"], + "indicators_short": ["h"], + }, + "info": "print help to stdout and exit", + }), + } + ); + const args : Record = arg_handler.read(lib_plankton.args.enum_environment.cli, args_raw.join(" ")); + + if (args["help"]) { + process.stdout.write( + arg_handler.generate_help( + { + "programname": "sindri", + "author": "Christian Fraß ", + "description": "create data model scripts in different output formats (MySQL, SQLite, …) on basis of an abstract description; feed with .sindri.json file via stdin!", + "executable": "sindri", + } + ) + ); + } + else { + if (args["schema"]) { + process.stdout.write( + JSON.stringify(_sindri.input_schema(), undefined, "\t") + ); + } + else { + if (args["list"]) { + process.stdout.write( + _sindri.list_outputs() + .map( + entry => lib_plankton.string.coin( + "{{realm}}:{{implementation}}\n", + { + "realm": entry.realm, + "implementation": entry.implementation, + } + ) + ) + .join("") + ); + } + else { + const input_content : string = await lib_plankton.file.read_stdin(); + const input_data_raw : any = lib_plankton.json.decode(input_content); + const input_data : type_input = _sindri.input_normalize(input_data_raw); + + const format_parts : Array = args["format"].split(":"); + const realm_encoded : string = format_parts[0]; + const realm : _sindri.enum_realm = { + "database": _sindri.enum_realm.database, + "backend": _sindri.enum_realm.backend, + "frontend": _sindri.enum_realm.frontend, + "other": _sindri.enum_realm.other, + }[realm_encoded]; + const name : string = format_parts.slice(1).join(":"); + + let output : (null | _sindri.type_output); + try { + output = _sindri.get_output(realm, name); + } + catch (error) { + output = null; + } + if (output === null) { + throw (new Error("unhandled output format: " + args["format"])); + } + else { + const output_content : string = await output.render(input_data); + process.stdout.write(output_content); + } + } + } + } + } + +} + + +_sindri.main(process.argv.slice(2)); diff --git a/source/outputs/backend/typescript/logic.ts b/source/outputs/backend/typescript/logic.ts new file mode 100644 index 0000000..8672f89 --- /dev/null +++ b/source/outputs/backend/typescript/logic.ts @@ -0,0 +1,339 @@ +namespace _sindri.outputs.backend.typescript +{ + + /** + */ + async function get_template( + name : string + ) : Promise + { + return _sindri.get_template(_sindri.enum_realm.backend, "typescript", name + ".ts.tpl"); + } + + + /** + */ + async function coin( + template_name : string, + values : Record + ) : Promise + { + return lib_plankton.string.coin( + await get_template(template_name), + values, + { + "open": "<<", + "close": ">>", + } + ); + } + + + /** + */ + export async function render( + input_data + ) : Promise + { + // TODO as command line argument? + const conf_internal : { + namespace_base : string; + } = { + "namespace_base": "_sindri.", + }; + + const map_primitive_type = function (typename : string) : lib_plankton.prog.struct_type { + const mymap : Record = { + "boolean": new lib_plankton.prog.struct_type_boolean(), + "integer": new lib_plankton.prog.struct_type_integer(), + // "float": new lib_plankton.prog.struct_type_integer(), + "string_short": new lib_plankton.prog.struct_type_string(), + "string_medium": new lib_plankton.prog.struct_type_string(), + "string_long": new lib_plankton.prog.struct_type_string(), + }; + return mymap[typename]; + }; + const name_table = function (domain) : string {return (domain.name);}; + const database_path = lib_plankton.string.coin( + "/tmp/{{name}}.sqlite", + { + "name": "sindri", + } + ); + const namespace_entity = function (domain) { + return lib_plankton.string.coin( + "{{base}}entities.{{domain_name}}", + { + "base": conf_internal.namespace_base, + "domain_name": domain.name, + } + ); + }; + const name_entity_type = function (fully_qualified, domain) : string { + return lib_plankton.string.coin( + "{{prefix}}type_value", + { + "prefix": ( + fully_qualified + ? (namespace_entity(domain) + ".") + : "" + ), + } + ); + }; + const namespace_repository = function (domain) { + return lib_plankton.string.coin( + "{{base}}repositories", + { + "base": conf_internal.namespace_base, + } + ); + }; + const name_repository_function = function (fully_qualified, domain, action) : string { + return lib_plankton.string.coin( + "{{prefix}}{{action}}", + { + "prefix": ( + fully_qualified + ? namespace_repository(domain) + : "" + ), + "action": action, + } + ); + }; + + return coin( + "master", + { + "namespace_base": conf_internal.namespace_base, + "entities": ( + (await Promise.all( + input_data["domains"] + .map( + (domain) => coin( + "entity", + { + "domain_name": domain.name, + "defs": lib_plankton.prog.typescript.render_statement( + new lib_plankton.prog.struct_statement_type_definition( + name_entity_type(false, domain), + new lib_plankton.prog.struct_type_record( + domain.data_fields + .map( + (data_field) => ({ + "name": data_field.name, + "type": ( + data_field.nullable + ? new lib_plankton.prog.struct_type_union( + new lib_plankton.prog.struct_type_literal( + new lib_plankton.prog.struct_expression_literal( + null + ) + ), + map_primitive_type(data_field["type"]) + ) + : map_primitive_type(data_field["type"]) + ), + "mandatory": true, + }) + ) + ), + { + "export": true, + } + ), + { + "level": 2, + } + ) + } + ) + ) + )) + .join("") + ), + "repositories": ( + (await Promise.all( + input_data["domains"] + .map( + (domain) => coin( + "repository", + { + "domain_name": domain.name, + "type_name": name_entity_type(true, domain), + "table_name": name_table(domain), + "list_function_name": name_repository_function(false, domain, "list"), + "list_query_fields": ( + [domain.key_field.name] + .concat(domain.data_fields.map(field => field.name)) + .join(",") + ), + "list_result": lib_plankton.prog.typescript.render_expression( + new lib_plankton.prog.struct_expression_dict( + [ + { + "key": "key", + "value": new lib_plankton.prog.struct_expression_projection( + new lib_plankton.prog.struct_expression_variable("row"), + new lib_plankton.prog.struct_expression_literal(domain.key_field.name) + ), + }, + { + "key": "value", + "value": new lib_plankton.prog.struct_expression_dict( + domain.data_fields + .map( + (field, index) => ({ + "key": field.name, + "value": new lib_plankton.prog.struct_expression_projection( + new lib_plankton.prog.struct_expression_variable("row"), + new lib_plankton.prog.struct_expression_literal(field.name) + ) + }) + ) + ), + }, + ] + ), + { + "indent": false, + "level": 8, + } + ), + "read_function_name": name_repository_function(false, domain, "read"), + "read_query_fields": ( + [] + .concat(domain.data_fields.map(field => field.name)) + .join(",") + ), + "read_result_fields": lib_plankton.prog.typescript.render_expression( + new lib_plankton.prog.struct_expression_dict( + domain.data_fields + .map( + (field, index) => ({ + "key": field.name, + "value": new lib_plankton.prog.struct_expression_projection( + new lib_plankton.prog.struct_expression_variable("row"), + new lib_plankton.prog.struct_expression_literal(field.name) + ) + }) + ) + ), + { + "indent": false, + "level": 6, + } + ), + "create_function_name": name_repository_function(false, domain, "create"), + "create_query_field_names": ( + domain.data_fields + .map(field => field.name) + .join(",") + ), + "create_query_field_placeholders": ( + domain.data_fields + .map(field => (":" + field.name)) + .join(",") + ), + "create_query_field_values": lib_plankton.prog.typescript.render_expression( + new lib_plankton.prog.struct_expression_dict( + domain.data_fields + .map( + field => ({ + "key": field.name, + "value": new lib_plankton.prog.struct_expression_fieldaccess( + new lib_plankton.prog.struct_expression_variable("value"), + field.name, + ), + }) + ) + ), + { + "indent": false, + "level": 6, + } + ), + "update_function_name": name_repository_function(false, domain, "update"), + "update_query_assignments": ( + domain.data_fields + .map( + field => lib_plankton.string.coin( + "{{key}} = {{value}}", + { + "key": field.name, + "value": (":" + ("value_" + field.name)), + } + ) + ) + .join(", ") + ), + "update_query_values": lib_plankton.prog.typescript.render_expression( + new lib_plankton.prog.struct_expression_dict( + [] + .concat( + [ + { + "key": "key", + "value": new lib_plankton.prog.struct_expression_variable("key"), + }, + ] + ) + .concat( + domain.data_fields + .map( + field => ({ + "key": ("value_" + field.name), + "value": new lib_plankton.prog.struct_expression_fieldaccess( + new lib_plankton.prog.struct_expression_variable("value"), + field.name, + ), + }) + ) + ) + ), + { + "indent": false, + "level": 7, + } + ), + "delete_function_name": name_repository_function(false, domain, "delete"), + } + ) + ) + )) + .join("") + ), + "api": ( + (await Promise.all( + input_data["domains"] + .map( + (domain) => coin( + "api", + { + "domain_name": domain.name, + "type_name": name_entity_type(true, domain), + "repository_function_list": name_repository_function(true, domain, "list"), + "repository_function_read": name_repository_function(true, domain, "read"), + "repository_function_create": name_repository_function(true, domain, "create"), + "repository_function_update": name_repository_function(true, domain, "update"), + "repository_function_delete": name_repository_function(true, domain, "delete"), + } + ) + ) + )) + .join("") + ), + } + ); + } + +} + +_sindri.add_output( + _sindri.enum_realm.backend, + "typescript", + { + "render": _sindri.outputs.backend.typescript.render, + } +); diff --git a/source/outputs/backend/typescript/templates/api.ts.tpl b/source/outputs/backend/typescript/templates/api.ts.tpl new file mode 100644 index 0000000..35767e7 --- /dev/null +++ b/source/outputs/backend/typescript/templates/api.ts.tpl @@ -0,0 +1,118 @@ + // <> + { + lib_plankton.rest.register( + rest, + lib_plankton.http.enum_method.get, + lib_plankton.string.coin( + "/{{base_path}}{{domain_name}}", + { + "base_path": _brock.conf.api_base_path, + "domain_name": "<>", + } + ), + { + "execution": async function (stuff) { + return { + "status_code": 200, + "data": await <>( + + ) + }; + } + } + ); + lib_plankton.rest.register( + rest, + lib_plankton.http.enum_method.get, + lib_plankton.string.coin( + "/{{base_path}}{{domain_name}}/:id", + { + "base_path": _brock.conf.api_base_path, + "domain_name": "<>", + } + ), + { + "execution": async function (stuff) { + return { + "status_code": 200, + "data": await <>( + parseInt( + stuff.path_parameters["id"] + ) + ) + }; + } + } + ); + lib_plankton.rest.register( + rest, + lib_plankton.http.enum_method.post, + lib_plankton.string.coin( + "/{{base_path}}{{domain_name}}", + { + "base_path": _brock.conf.api_base_path, + "domain_name": "<>", + } + ), + { + "execution": async function (stuff) { + const id = await <>( + (stuff.input as <>) + ); + return { + "status_code": 201, + "data": id + }; + } + } + ); + lib_plankton.rest.register( + rest, + lib_plankton.http.enum_method.patch, + lib_plankton.string.coin( + "/{{base_path}}{{domain_name}}/:id", + { + "base_path": _brock.conf.api_base_path, + "domain_name": "<>", + } + ), + { + "execution": async function (stuff) { + const dummy = await <>( + parseInt( + stuff.path_parameters["id"] + ), + (stuff.input as <>) + ); + return { + "status_code": 200, + "data": null + }; + } + } + ); + lib_plankton.rest.register( + rest, + lib_plankton.http.enum_method.delete, + lib_plankton.string.coin( + "/{{base_path}}{{domain_name}}/:id", + { + "base_path": _brock.conf.api_base_path, + "domain_name": "<>", + } + ), + { + "execution": async function (stuff) { + const dummy = await <>( + parseInt( + stuff.path_parameters["id"] + ) + ); + return { + "status_code": 200, + "data": null + }; + } + } + ); + } diff --git a/source/outputs/backend/typescript/templates/entity.ts.tpl b/source/outputs/backend/typescript/templates/entity.ts.tpl new file mode 100644 index 0000000..a9d6cb7 --- /dev/null +++ b/source/outputs/backend/typescript/templates/entity.ts.tpl @@ -0,0 +1,4 @@ + export namespace <> + { +<> + } diff --git a/source/outputs/backend/typescript/templates/master.ts.tpl b/source/outputs/backend/typescript/templates/master.ts.tpl new file mode 100644 index 0000000..967d7c5 --- /dev/null +++ b/source/outputs/backend/typescript/templates/master.ts.tpl @@ -0,0 +1,74 @@ +// declare var require; + +namespace <>entities +{ +<> +} + + +namespace <>repositories +{ +<> +} + + +namespace <>main +{ + // run + export function run( + ) : void + { + lib_plankton.log.conf_push( + [ + new lib_plankton.log.class_channel_stdout( + + ) + ] + ); + + // define api + { + // meta + { + lib_plankton.rest.register( + rest, + lib_plankton.http.enum_method.get, + "/_spec", + { + "execution": async function (stuff) { + return { + "status_code": 200, + "data": lib_plankton.rest.to_oas( + rest + ) + }; + } + } + ); + } +<> + } + + // setup server + const server = lib_plankton.server.make( + _brock.conf.server_port, + async function (input) { + const http_request : lib_plankton.http.type_request = lib_plankton.http.decode_request( + input + ); + const http_response : lib_plankton.http.type_response = await lib_plankton.rest.call( + rest, + http_request + ); + return lib_plankton.http.encode_response( + http_response + ); + } + ); + + // start + lib_plankton.server.start( + server + ); + } +} diff --git a/source/outputs/backend/typescript/templates/repository.ts.tpl b/source/outputs/backend/typescript/templates/repository.ts.tpl new file mode 100644 index 0000000..0dfc38a --- /dev/null +++ b/source/outputs/backend/typescript/templates/repository.ts.tpl @@ -0,0 +1,113 @@ + export namespace <> + { + + // list + export function <>( + ) : Promise>;}>> + { + return ( + lib_plankton.sqlite.query_get( + _brock.conf.database_path, + { + "template": "SELECT <> FROM <>;", + "arguments": { + + } + } + ) + .then( + (rows) => rows.map( + (row) => <> + ) + ) + ); + } + + // read + export function <>( + key : number + ) : Promise<<>> + { + return ( + lib_plankton.sqlite.query_get( + _brock.conf.database_path, + { + "template": "SELECT <> FROM <> WHERE (id = :key);", + "arguments": { + "key": key + } + } + ) + .then( + (rows) { + const row = rows[0]; + return <>; + } + ) + ); + } + + // create + export function <>( + value : <> + ) : Promise + { + return ( + lib_plankton.sqlite.query_put( + _brock.conf.database_path, + { + "template": "INSERT INTO <>(<>) VALUES (<>);", + "arguments": <> + } + ) + .then( + (result) => result.id + ) + ); + } + + // update + export function <>( + key : number, + value : <> + ) : Promise + { + return ( + lib_plankton.sqlite.query_put( + _brock.conf.database_path, + { + "template": "UPDATE <> SET <> WHERE (id = :key);", + "arguments": { + "key": key, + <> + } + } + ) + .then( + (result) => {} + ) + ); + } + + // delete + export function <>( + key : number + ) : Promise + { + return ( + lib_plankton.sqlite.query_put( + _brock.conf.database_path, + { + "template": "DELETE FROM <> WHERE (id = :key);", + "arguments": { + "key": key + } + } + ) + .then( + (result) => {} + ) + ); + } + + } diff --git a/source/outputs/database/mysql/logic.ts b/source/outputs/database/mysql/logic.ts new file mode 100644 index 0000000..ef37973 --- /dev/null +++ b/source/outputs/database/mysql/logic.ts @@ -0,0 +1,221 @@ +namespace _sindri.outputs.database.mysql +{ + + /** + */ + function value_encode( + value : any + ) : string + { + if (value === null) { + return "NULL"; + } + else { + switch (typeof(value)) { + case "boolean": { + return (value ? "TRUE" : "FALSE"); + break; + } + case "number": { + return value.toString(); + break; + } + case "string": { + return ("'" + value + "'"); + break; + } + default: { + throw (new Error("unhandled")); + break; + } + } + } + } + + + /** + */ + export function render( + input_data + ) : string + { + return ( + input_data.domains + .map( + (domain) => lib_plankton.string.coin( + "CREATE TABLE\n\t`{{name}}`(\n{{entries}}\n\t){{comment}}\n;", + { + "name": domain.name, + "comment": ( + (domain.description === null) + ? "" + : lib_plankton.string.coin( + " COMMENT '{{comment}}'", + { + "comment": domain.description, + } + ) + ), + "entries": ( + ( + [] + // key field + .concat( + (domain.key_field === null) + ? [] + : lib_plankton.string.coin( + "`{{name}}` {{parameters}}", + { + "name": domain.key_field.name, + "parameters": ( + [ + "INTEGER", + "PRIMARY KEY", + "AUTO INCREMENT", + ] + .concat( + (domain.key_field.description === null) + ? [] + : [ + lib_plankton.string.coin( + "COMMENT '{{comment}}'", + { + "comment": domain.key_field.description, + } + ), + ] + ) + .join(" ") + ), + } + ) + ) + // data fields + .concat( + domain.data_fields + .map( + (data_field) => lib_plankton.string.coin( + "`{{name}}` {{parameters}}", + { + "name": data_field.name, + "parameters": ( + ( + // type + [ + { + "boolean": "BOOLEAN", + "integer": "INTEGER", + "string_short": "VARCHAR(63)", + "string_medium": "VARCHAR(255)", + "string_long": "TEXT", + }[data_field.type], + ] + // nullability + .concat( + data_field.nullable + ? ["NULL"] + : [] + ) + // default + .concat( + (data_field.default === undefined) + ? [] + : [ + lib_plankton.string.coin( + "DEFAULT {{value}}", + { + "value": value_encode(data_field.default), + } + ), + ] + ) + // comment + .concat( + (data_field.description === null) + ? [] + : [ + lib_plankton.string.coin( + "COMMENT '{{comment}}'", + { + "comment": data_field.description, + } + ), + ] + ) + ) + .join(" ") + ) + } + ) + ) + ) + // constraints + .concat( + domain["constraints"] + .map( + (constraint) => { + switch (constraint.kind) { + default: { + throw (new Error("unhandled constraint kind: " + constraint.kind)); + break; + } + case "foreign_key": { + return lib_plankton.string.coin( + "FOREIGN KEY ({{fields}}) REFERENCES `{{reference_name}}`({{reference_fields}})", + { + "fields": ( + constraint.parameters["fields"] + .map(x => ('`' + x + '`')) + .join(",") + ), + "reference_name": constraint.parameters["reference"]["name"], + "reference_fields": ( + constraint.parameters["reference"]["fields"] + .map(x => ('`' + x + '`')) + .join(",") + ), + } + ); + break; + } + case "unique": { + return lib_plankton.string.coin( + "UNIQUE ({{fields}})", + { + "fields": ( + constraint.parameters["fields"] + .map(x => ('`' + x + '`')) + .join(",") + ), + } + ); + break; + } + } + } + ) + ) + ) + .map(x => ("\t\t" + x)) + .join(",\n") + ), + } + ) + ) + .map(x => (x + "\n")) + .join("\n") + ); + } + +} + + +/** + */ +_sindri.add_output( + _sindri.enum_realm.database, + "mysql", + { + "render": (x) => Promise.resolve(_sindri.outputs.database.mysql.render(x)), + } +); diff --git a/source/outputs/database/postgresql/logic.ts b/source/outputs/database/postgresql/logic.ts new file mode 100644 index 0000000..38d675e --- /dev/null +++ b/source/outputs/database/postgresql/logic.ts @@ -0,0 +1,255 @@ +namespace _sindri.outputs.database.postgresql +{ + + /** + */ + function value_encode( + value : any + ) : string + { + if (value === null) { + return "NULL"; + } + else { + switch (typeof(value)) { + case "boolean": { + return (value ? "TRUE" : "FALSE"); + break; + } + case "number": { + return value.toString(); + break; + } + case "string": { + return ("'" + value + "'"); + break; + } + default: { + throw (new Error("unhandled")); + break; + } + } + } + } + + + /** + */ + export function render( + input_data + ) : string + { + return ( + input_data.domains + .map( + (domain) => lib_plankton.string.coin( + "CREATE TABLE\n\t{{name}}(\n{{entries}}\n\t)\n;\n{{comments}}", + { + "name": domain.name, + "entries": ( + ( + [] + // key field + .concat( + (domain.key_field === null) + ? [] + : lib_plankton.string.coin( + "{{name}} {{parameters}}", + { + "name": ('"' + domain.key_field.name + '"'), + "parameters": ( + [ + "SERIAL", + ] + .join(" ") + ), + } + ) + ) + // data fields + .concat( + domain.data_fields + .map( + (data_field) => lib_plankton.string.coin( + "{{name}} {{parameters}}", + { + "name": ('"' + data_field.name + '"'), + "parameters": ( + ( + // type + [ + { + "boolean": "BOOLEAN", + "integer": "INTEGER", + "string_short": "VARCHAR(63)", + "string_medium": "VARCHAR(255)", + "string_long": "TEXT", + }[data_field.type], + ] + // nullability + .concat( + data_field.nullable + ? [] + : ["NOT NULL"] + ) + // default + .concat( + (data_field.default === undefined) + ? [] + : [ + lib_plankton.string.coin( + "DEFAULT {{value}}", + { + "value": value_encode(data_field.default), + } + ), + ] + ) + ) + .join(" ") + ) + } + ) + ) + ) + // constraints + .concat( + domain["constraints"] + .concat( + (domain.key_field === null) + ? + [] + : + [ + { + "kind": "unique", + "parameters": { + "fields": [ + domain.key_field.name, + ] + } + }, + ] + ) + .map( + (constraint) => { + switch (constraint.kind) { + default: { + throw (new Error("unhandled constraint kind: " + constraint.kind)); + break; + } + case "foreign_key": { + return lib_plankton.string.coin( + "FOREIGN KEY ({{fields}}) REFERENCES {{reference_name}}({{reference_fields}})", + { + "fields": ( + constraint.parameters["fields"] + .map(x => ('"' + x + '"')) + .join(",") + ), + "reference_name": ('"' + constraint.parameters["reference"]["name"] + '"'), + "reference_fields": ( + constraint.parameters["reference"]["fields"] + .map(x => ('"' + x + '"')) + .join(",") + ), + } + ); + break; + } + case "unique": { + return lib_plankton.string.coin( + "UNIQUE ({{fields}})", + { + "fields": ( + constraint.parameters["fields"] + .map(x => ('"' + x + '"')) + .join(",") + ), + } + ); + break; + } + } + } + ) + ) + ) + .map(x => ("\t\t" + x)) + .join(",\n") + ), + "comments": ( + ( + [] + .concat( + (! (domain.description === null)) + ? [ + { + "kind": "TABLE", + "subject": domain.name, + "value": domain.description, + } + ] + : [] + ) + .concat( + ( + (! (domain.key_field === null)) + && + (! (domain.key_field.description === null)) + ) + ? [ + { + "kind": "COLUMN", + "subject": (domain.name + "." + domain.key_field.name), + "value": domain.key_field.description, + } + ] + : [] + ) + .concat( + domain.data_fields + .filter( + data_field => (! (data_field.description === null)) + ) + .map( + data_field => ({ + "kind": "COLUMN", + "subject": (domain.name + "." + data_field.name), + "value": data_field.description, + }) + ) + ) + ) + .map( + entry => lib_plankton.string.coin( + "COMMENT ON {{kind}} {{subject}} IS '{{value}}';", + { + "kind": entry.kind, + "subject": entry.subject, + "value": entry.value, + } + ) + ) + .join("\n") + ), + } + ) + ) + .map(x => (x + "\n")) + .join("\n") + ); + } + +} + + +/** + */ +_sindri.add_output( + _sindri.enum_realm.database, + "postgresql", + { + "render": (x) => Promise.resolve(_sindri.outputs.database.postgresql.render(x)), + } +); diff --git a/source/outputs/database/sqlite/logic.ts b/source/outputs/database/sqlite/logic.ts new file mode 100644 index 0000000..5d3fa23 --- /dev/null +++ b/source/outputs/database/sqlite/logic.ts @@ -0,0 +1,183 @@ +namespace _sindri.outputs.database.sqlite +{ + + /** + */ + function value_encode( + value : any + ) : string + { + if (value === null) { + return "NULL"; + } + else { + switch (typeof(value)) { + case "boolean": { + return (value ? "TRUE" : "FALSE"); + break; + } + case "number": { + return value.toString(); + break; + } + case "string": { + return ("'" + value + "'"); + break; + } + default: { + throw (new Error("unhandled")); + break; + } + } + } + } + + + /** + */ + export function render( + input_data + ) : string + { + return ( + input_data["domains"] + .map( + (domain) => lib_plankton.string.coin( + "CREATE TABLE\n\t`{{name}}`(\n{{entries}}\n\t)\n;", + { + "name": domain.name, + "entries": ( + ( + [] + // key field + .concat( + (domain.key_field === null) + ? [] + : lib_plankton.string.coin( + "`{{name}}` {{parameters}}", + { + "name": domain.key_field.name, + "parameters": ( + [ + "INTEGER", + "PRIMARY KEY", + "AUTOINCREMENT", + ] + .join(" ") + ), + } + ) + ) + // data fields + .concat( + domain.data_fields + .map( + (data_field) => lib_plankton.string.coin( + "`{{name}}` {{parameters}}", + { + "name": data_field.name, + "parameters": ( + ( + // type + [ + { + "boolean": "BOOLEAN", + "integer": "INTEGER", + "string_short": "VARCHAR(63)", + "string_medium": "VARCHAR(255)", + "string_long": "TEXT", + }[data_field.type], + ] + // nullability + .concat( + data_field.nullable + ? [] + : ["NOT NULL"] + ) + // default + .concat( + (data_field.default === undefined) + ? [] + : [ + lib_plankton.string.coin( + "DEFAULT {{value}}", + { + "value": value_encode(data_field.default), + } + ), + ] + ) + ) + .join(" ") + ) + } + ) + ) + ) + // constraints + .concat( + domain.constraints + .map( + (constraint) => { + switch (constraint.kind) { + default: { + throw (new Error("unhandled constraint kind: " + constraint.kind)); + break; + } + case "foreign_key": { + return lib_plankton.string.coin( + "FOREIGN KEY ({{fields}}) REFERENCES `{{reference_name}}`({{reference_fields}})", + { + "fields": ( + constraint.parameters["fields"] + .map(x => ('`' + x + '`')) + .join(",") + ), + "reference_name": constraint.parameters["reference"]["name"], + "reference_fields": ( + constraint.parameters["reference"]["fields"] + .map(x => ('`' + x + '`')) + .join(",") + ), + } + ); + break; + } + case "unique": { + return lib_plankton.string.coin( + "UNIQUE ({{fields}})", + { + "fields": ( + constraint.parameters["fields"] + .map(x => ('`' + x + '`')) + .join(",") + ), + } + ); + break; + } + } + } + ) + ) + ) + .map(x => ("\t\t" + x)) + .join(",\n") + ), + } + ) + ) + .map(x => (x + "\n")) + .join("\n") + ); + } + +} + +_sindri.add_output( + _sindri.enum_realm.database, + "sqlite", + { + "render": (x) => Promise.resolve(_sindri.outputs.database.sqlite.render(x)), + } +); diff --git a/source/outputs/frontend/typescript/logic.ts b/source/outputs/frontend/typescript/logic.ts new file mode 100644 index 0000000..4f2f144 --- /dev/null +++ b/source/outputs/frontend/typescript/logic.ts @@ -0,0 +1,37 @@ +namespace _sindri.outputs.frontend.typescript +{ + + /** + */ + async function get_template( + name : string + ) : Promise + { + return _sindri.get_template(_sindri.enum_realm.frontend, "typescript", name); + } + + + /** + */ + export async function render( + input_data + ) : Promise + { + return lib_plankton.string.coin( + await get_template("core.ts.tpl"), + { + "value": JSON.stringify(input_data, undefined, "\t"), + } + ); + } + +} + + +_sindri.add_output( + _sindri.enum_realm.frontend, + "typescript", + { + "render": _sindri.outputs.frontend.typescript.render, + } +); diff --git a/source/outputs/frontend/typescript/templates/core.ts.tpl b/source/outputs/frontend/typescript/templates/core.ts.tpl new file mode 100644 index 0000000..c065713 --- /dev/null +++ b/source/outputs/frontend/typescript/templates/core.ts.tpl @@ -0,0 +1,251 @@ +namespace _sindri +{ + + /** + */ + const abstract = {{value}}; + + + /** + * @todo headers + * @todo query + */ + export function api_call( + method : string, + path : string, + input : any = null + ) : Promise + { + return ( + fetch( + (conf.backend.scheme + "://" + conf.backend.host + ":" + conf.backend.port.toFixed() + path), + { + "method": method, + "headers": { + "Content-Type": "application/json", + }, + "body": ( + (input === null) + ? undefined + : /*Buffer.from*/(JSON.stringify(input)) + ), + } + ) + .then( + x => x.json() + ) + ); + } + + + /** + */ + export function editor( + domain_description : any, + hook_switch : (null | ((state : lib_plankton.zoo_editor.type_state) => void)) + ) : lib_plankton.zoo_editor.type_editor + { + return lib_plankton.zoo_editor.make( + // store + { + "setup": () => Promise.resolve(undefined), + "search": (term) => ( + api_call( + "GET", + lib_plankton.string.coin( + "/{{name}}", + { + "name": domain_description.name, + } + ), + null + ) + .then( + (entries) => Promise.resolve>( + entries + .filter( + entry => ( + entry.key.toFixed().includes(term.toLowerCase()) + || + ( + /* + (term.length >= 3) + && + */ + domain_description.data_fields + .some( + data_field => JSON.stringify(entry.value[data_field.name]).toLowerCase().includes(term.toLowerCase()) + ) + ) + ) + ) + .map( + entry => ({ + "key": entry.key, + "preview": entry.value, + }) + ) + ) + ) + ), + "read": (id) => api_call( + "GET", + lib_plankton.string.coin( + "/{{name}}/{{id}}", + { + "name": domain_description.name, + "id": id.toFixed(0), + } + ), + null + ), + "create": (object) => api_call( + "POST", + lib_plankton.string.coin( + "/{{name}}", + { + "name": domain_description.name, + } + ), + object + ), + "update": (id, object) => api_call( + "PATCH", + lib_plankton.string.coin( + "/{{name}}/{{id}}", + { + "name": domain_description.name, + "id": id.toFixed(0), + } + ), + object + ), + "delete": (id) => api_call( + "DELETE", + lib_plankton.string.coin( + "/{{name}}/{{id}}", + { + "name": domain_description.name, + "id": id.toFixed(0), + } + ), + null + ), + }, + // form + lib_plankton.zoo_form.make( + // method + "GET", + // fields + ( + domain_description.data_fields.map( + data_field => ({ + "name": data_field.name, + "type": { + "string_short": "text", + "string_medium": "text", + "string_long": "text", + "integer": "number", + "float": "number", + }[data_field.type], + }) + ) + ), + // encode + (object) => object, + // decode + (object_encoded) => object_encoded, + ), + // options + { + "hook_switch": hook_switch, + } + ); + } + + + /** + */ + export function edit_location_name( + domain_description + ) : string + { + return lib_plankton.string.coin( + "edit_{{name}}", + { + "name": domain_description.name, + } + ); + } + + + /** + */ + export function register_editor_page_for_domain( + domain_description + ) : void + { + const location_name : string = edit_location_name(domain_description); + lib_plankton.zoo_page.register( + location_name, + async (parameters, element_main) => { + const id : (null | int) = ((! ("id" in parameters)) ? null : parseInt(parameters["id"])); + const mode : lib_plankton.zoo_editor.enum_mode = editor_decode_mode(parameters["mode"], id); + const search_term : (null | string) = (parameters["search"] ?? null); + lib_plankton.zoo_editor.render( + editor( + domain_description, + (state) => { + lib_plankton.zoo_page.set( + { + "name": location_name, + "parameters": { + "mode": state.mode, + "id": ((state.key === null) ? null : state.key.toFixed(0)), + "search": state.search_state.term, + }, + } + ); + } + ), + element_main, + { + "state": { + "mode": mode, + "key": id, + "search_state": {"term": search_term}, + } + } + ); + } + ); + lib_plankton.zoo_page.add_nav_entry( + { + "name": location_name, + "parameters": { + "mode": "find", + "key": null, + "search": "" + } + }, + { + "label": (domain_description.name + "s"), + } + ); + } + + + /** + */ + export function init( + ) : Promise + { + abstract.domains.forEach( + domain_description => { + register_editor_page_for_domain(domain_description); + } + ); + return Promise.resolve(undefined); + } + +} diff --git a/source/outputs/other/jsonschema/logic.ts b/source/outputs/other/jsonschema/logic.ts new file mode 100644 index 0000000..d36eca5 --- /dev/null +++ b/source/outputs/other/jsonschema/logic.ts @@ -0,0 +1,103 @@ +namespace _sindri.outputs.other.jsonschema +{ + + /** + */ + export function render( + input_data + ) : string + { + return lib_plankton.json.encode( + Object.fromEntries( + input_data.domains.map( + domain => ([ + domain.name, + { + "type": ["array"], + "items": { + "type": ["object"], + "additionalProperties": false, + "properties": Object.fromEntries( + [] + .concat( + (domain.key_field === null) + ? [] + : [ + [ + domain.key_field.name, + { + "type": ["integer"], + "description": (domain.key_field.description ?? undefined), + } + ] + ] + ) + .concat( + domain.data_fields + .map( + data_field => ([ + data_field.name, + { + "type": ( + [] + .concat( + data_field.nullable + ? ["null"] + : [] + ) + .concat( + [ + { + "boolean": "boolean", + "integer": "integer", + "float": "number", + "string_short": "string", + "string_medium": "string", + "string_long": "string", + }[data_field.type] + ] + ) + ), + "description": (data_field.description ?? undefined), + } + ]) + ) + ) + ), + "required": ( + [] + .concat( + (domain.key_field === null) + ? [] + : [domain.key_field.name] + ) + .concat( + domain.data_fields + .map( + data_field => data_field.name + ) + ) + ) + }, + } + ]) + ) + ), + { + "formatted": true + } + ); + } + +} + + +/** + */ +_sindri.add_output( + _sindri.enum_realm.other, + "jsonschema", + { + "render": (x) => Promise.resolve(_sindri.outputs.other.jsonschema.render(x)), + } +); diff --git a/todo.md b/todo.md new file mode 100644 index 0000000..5d5b8e8 --- /dev/null +++ b/todo.md @@ -0,0 +1,3 @@ +- Nutzer-Verwaltung +- auf `plankton:database` setzen + diff --git a/tools/build b/tools/build new file mode 100755 index 0000000..773ec81 --- /dev/null +++ b/tools/build @@ -0,0 +1,4 @@ +#!/usr/bin/env sh + +make --file=tools/makefile + diff --git a/tools/clear b/tools/clear new file mode 100755 index 0000000..9236217 --- /dev/null +++ b/tools/clear @@ -0,0 +1,3 @@ +#!/usr/bin/env sh + +rm --recursive --force temp build diff --git a/tools/get-plankton b/tools/get-plankton new file mode 100755 index 0000000..2c286ca --- /dev/null +++ b/tools/get-plankton @@ -0,0 +1,15 @@ +#!/usr/bin/env sh + +modules="" +modules="${modules} base" +# modules="${modules} call" +modules="${modules} string" +modules="${modules} json" +modules="${modules} file" +modules="${modules} prog" +modules="${modules} args" + +mkdir -p lib/plankton +cd lib/plankton +ptk bundle node ${modules} +cd - diff --git a/tools/install b/tools/install new file mode 100755 index 0000000..eddde05 --- /dev/null +++ b/tools/install @@ -0,0 +1,3 @@ +#!/usr/bin/env sh + +cp build/sindri /usr/local/bin/sindri diff --git a/tools/makefile b/tools/makefile new file mode 100644 index 0000000..93923a6 --- /dev/null +++ b/tools/makefile @@ -0,0 +1,44 @@ +## commands + +cmd_create_directory := mkdir --parents +cmd_typescript_compile := tsc +cmd_concatenate := cat +cmd_chmod := chmod +cmd_echo := echo -e +cmd_echox := echo +cmd_log := echo -e "--" +cmd_copy := cp -r -u -v + + +## rules + +.PHONY: all +all: build/sindri templates + +temp/sindri-unlinked.js: \ +lib/plankton/plankton.d.ts \ +source/base.ts \ +source/outputs/other/jsonschema/logic.ts \ +source/outputs/database/sqlite/logic.ts \ +source/outputs/database/mysql/logic.ts \ +source/outputs/database/postgresql/logic.ts \ +source/outputs/backend/typescript/logic.ts \ +source/outputs/frontend/typescript/logic.ts \ +source/conf.ts \ +source/main.ts + @ ${cmd_log} "compiling …" + @ ${cmd_create_directory} temp + @ ${cmd_typescript_compile} $^ --lib es2020 --target es6 --outFile $@ + +build/sindri: lib/plankton/plankton.js temp/sindri-unlinked.js + @ ${cmd_log} "linking …" + @ ${cmd_create_directory} build + @ ${cmd_echox} "#!/usr/bin/env node" > temp/head.js + @ ${cmd_concatenate} temp/head.js $^ > $@ + @ ${cmd_chmod} +x $@ + +.PHONY: templates +templates: \ + source/outputs/frontend/typescript/templates/core.ts.tpl + @ ${cmd_log} "placing templates …" + @ tools/place-templates diff --git a/tools/place-templates b/tools/place-templates new file mode 100755 index 0000000..3c844e8 --- /dev/null +++ b/tools/place-templates @@ -0,0 +1,17 @@ +#!/usr/bin/env bash + +## consts + +dir_from=source/outputs +dir_to=build/templates + + +## exec + +paths=$(find ${dir_from} -type d -name templates) +for path in ${paths} +do + type=$(echo ${path} | cut --delimiter='/' --fields='3-' | cut --delimiter='/' --fields='-2') + mkdir --parents ${dir_to}/${type} + cp --update --verbose ${path}/* ${dir_to}/${type}/ +done