jsf.js_next_gen 4.0.1-beta.6 → 4.0.1-beta.8

package/target/types/main/typescript/Config.d.ts

@@ -0,0 +1,94 @@
+import { IValueHolder, Optional } from "./Monad";
+export declare const CONFIG_VALUE = "__END_POINT__";
+export declare const CONFIG_ANY = "__ANY_POINT__";
+export type ConfigDef = {
+    [key: string]: any;
+};
+/**
+ * Config, basically an optional wrapper for a json structure
+ * (not Side - effect free, since we can alter the internal config state
+ * without generating a new config), not sure if we should make it side - effect free
+ * since this would swallow a lot of performance and ram
+ */
+export declare class Config extends Optional<any> {
+    private configDef?;
+    constructor(root: any, configDef?: ConfigDef);
+    /**
+     * shallow copy getter, copies only the first level, references the deeper nodes
+     * in a shared manner
+     */
+    get shallowCopy(): Config;
+    protected shallowCopy$(): Config;
+    /**
+     * deep copy, copies all config nodes
+     */
+    get deepCopy(): Config;
+    protected deepCopy$(): Config;
+    /**
+     * creates a config from an initial value or null
+     * @param value
+     */
+    static fromNullable<T>(value?: T | null): Config;
+    /**
+     * simple merge for the root configs
+     */
+    shallowMerge(other: Config, overwrite?: boolean, withAppend?: boolean): void;
+    /**
+     * assigns a single value as array, or appends it
+     * to an existing value mapping a single value to array
+     *
+     *
+     * usage myConfig.append("foobaz").value = "newValue"
+     *       myConfig.append("foobaz").value = "newValue2"
+     *
+     * resulting in myConfig.foobaz == ["newValue, newValue2"]
+     *
+     * @param {string[]} accessPath
+     */
+    append(...accessPath: string[]): IValueHolder<any>;
+    /**
+     * appends to an existing entry (or extends into an array and appends)
+     * if the condition is met
+     * @param {boolean} condition
+     * @param {string[]} accessPath
+     */
+    appendIf(condition: boolean, ...accessPath: string[]): IValueHolder<any>;
+    /**
+     * assigns a new value on the given access path
+     * @param accessPath
+     */
+    assign(...accessPath: any[]): IValueHolder<any>;
+    /**
+     * assign a value if the condition is set to true, otherwise skip it
+     *
+     * @param condition the condition, the access accessPath into the config
+     * @param accessPath
+     */
+    assignIf(condition: boolean, ...accessPath: Array<any>): IValueHolder<any>;
+    /**
+     * get if the access path is present (get is reserved as getter with a default, on the current path)
+     * TODO will be renamed to something more meaningful and deprecated, the name is ambiguous
+     * @param accessPath the access path
+     */
+    getIf(...accessPath: Array<string>): Config;
+    /**
+     * gets the current node and if none is present returns a config with a default value
+     * @param defaultVal
+     */
+    get(defaultVal: any): Config;
+    delete(key: string): Config;
+    /**
+     * converts the entire config into a json object
+     */
+    toJson(): any;
+    protected getClass(): any;
+    private setVal;
+    /**
+     * asserts the access path for a semi typed access
+     * @param accessPath
+     * @private
+     */
+    private assertAccessPath;
+    private isNoArray;
+    private isArray;
+}

package/target/types/main/typescript/CryptoExtensions.d.ts

@@ -0,0 +1,87 @@
+/*!
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+import { Crypto, Hash } from "./Messaging";
+/**
+ * basic json stringify encryption impl
+ * this does not really full encryption except for a standard json stringyfywith an encapsulation json
+ *
+ * the return value resembles:
+ * <pre>
+ *     {
+ *         encryptedData: <data as string>
+ *     }
+ * </pre>
+ */
+export declare class JSONCrypto implements Crypto {
+    decode(data: any): any;
+    encode(data: any): {
+        encryptedData: string;
+    };
+}
+/**
+ * a class with  timeout functionality which blocks decodes after a certain period of time
+ * if the message is not decoded by then
+ * We use hash as identifier generation after encryption to make sure
+ * a trace was possible
+ *
+ * The idea behind this is to have a generic wrapper which allows messages with dynamic encryption
+ * where keys/salts only exist for a certain period of time before expiring!
+ * That way someone who implements such a scheme does not have to take care about the bookeeping mechanisms!
+ * Or you can use crypto mechanisms which do not have expiring keys and still expire them automatically
+ *
+ * I will leave it up to the system integrator to provide a rotating crypto class, because this is highly
+ * implementation dependent. But it helps to have a wrapper!
+ */
+export declare class ExpiringCrypto implements Crypto {
+    private timeout;
+    private parentCrypto;
+    private hashSum;
+    private static MAX_GC_CYCLES;
+    private gcCycleCnt;
+    private storedMessages;
+    private lastCall;
+    /**
+     * @param timeout timeout in miliseconds until a message is expired
+     * @param parentCrypto the embedded decorated crypto algorithm
+     * @param hashSum hashshum implementation to generate a hash
+     */
+    constructor(timeout: number, parentCrypto: Crypto, hashSum: Hash);
+    /**
+     * decode implementation with a timeout hook install
+     * @param data
+     */
+    decode(data: any): any;
+    /**
+     * trigger function to determine whether the gc needs to cycle again, this is either time or call based
+     * the gc itself collects only on expiration dates
+     * The idea is to run this operation only occasionally because it is costly
+     * We also could have used timeouts etc.. but those would need shutdown/destroy cleanups
+     *
+     * @param currTime
+     * @private
+     */
+    private gcLimitReached;
+    /**
+     * encode with a timeout hook installed
+     * calls the encode of the delegated object
+     *
+     * @param data
+     */
+    encode(data: any): any;
+}