fiftyone.pipeline.core 4.4.99 → 4.4.101

package/pipelineBuilder.js

@@ -1,23 +1,23 @@
-/* *********************************************************************
- * This Original Work is copyright of 51 Degrees Mobile Experts Limited.
- * Copyright 2023 51 Degrees Mobile Experts Limited, Davidson House,
- * Forbury Square, Reading, Berkshire, United Kingdom RG1 3EU.
- *
- * This Original Work is licensed under the European Union Public Licence
- * (EUPL) v.1.2 and is subject to its terms as set out below.
- *
- * If a copy of the EUPL was not distributed with this file, You can obtain
- * one at https://opensource.org/licenses/EUPL-1.2.
- *
- * The 'Compatible Licences' set out in the Appendix to the EUPL (as may be
- * amended by the European Commission) shall be deemed incompatible for
- * the purposes of the Work and the provisions of the compatibility
- * clause in Article 5 of the EUPL shall not apply.
- *
- * If using the Work as, or as part of, a network application, by
- * including the attribution notice(s) required under Article 5 of the EUPL
- * in the end user terms of the application under an appropriate heading,
- * such notice(s) shall fulfill the requirements of that article.
+/* *********************************************************************
+ * This Original Work is copyright of 51 Degrees Mobile Experts Limited.
+ * Copyright 2023 51 Degrees Mobile Experts Limited, Davidson House,
+ * Forbury Square, Reading, Berkshire, United Kingdom RG1 3EU.
+ *
+ * This Original Work is licensed under the European Union Public Licence
+ * (EUPL) v.1.2 and is subject to its terms as set out below.
+ *
+ * If a copy of the EUPL was not distributed with this file, You can obtain
+ * one at https://opensource.org/licenses/EUPL-1.2.
+ *
+ * The 'Compatible Licences' set out in the Appendix to the EUPL (as may be
+ * amended by the European Commission) shall be deemed incompatible for
+ * the purposes of the Work and the provisions of the compatibility
+ * clause in Article 5 of the EUPL shall not apply.
+ *
+ * If using the Work as, or as part of, a network application, by
+ * including the attribution notice(s) required under Article 5 of the EUPL
+ * in the end user terms of the application under an appropriate heading,
+ * such notice(s) shall fulfill the requirements of that article.
  * ********************************************************************* */
 
 const Pipeline = require('./pipeline');
@@ -131,6 +131,12 @@ class PipelineBuilder {
     return new Pipeline(flowElements, false, this.dataFileUpdateService);
   }
 
+  /**
+   * Add required elements to an existing FlowElement array
+   *
+   * @param {FlowElement[]} flowElements array of elements to add to
+   * @returns {FlowElement[]} resulting array with required elements
+   */
   addRequiredElements (flowElements) {
     return flowElements
       .concat(this.getJavaScriptElements())

package/sequenceElement.js

@@ -1,23 +1,23 @@
-/* *********************************************************************
- * This Original Work is copyright of 51 Degrees Mobile Experts Limited.
- * Copyright 2023 51 Degrees Mobile Experts Limited, Davidson House,
- * Forbury Square, Reading, Berkshire, United Kingdom RG1 3EU.
- *
- * This Original Work is licensed under the European Union Public Licence
- * (EUPL) v.1.2 and is subject to its terms as set out below.
- *
- * If a copy of the EUPL was not distributed with this file, You can obtain
- * one at https://opensource.org/licenses/EUPL-1.2.
- *
- * The 'Compatible Licences' set out in the Appendix to the EUPL (as may be
- * amended by the European Commission) shall be deemed incompatible for
- * the purposes of the Work and the provisions of the compatibility
- * clause in Article 5 of the EUPL shall not apply.
- *
- * If using the Work as, or as part of, a network application, by
- * including the attribution notice(s) required under Article 5 of the EUPL
- * in the end user terms of the application under an appropriate heading,
- * such notice(s) shall fulfill the requirements of that article.
+/* *********************************************************************
+ * This Original Work is copyright of 51 Degrees Mobile Experts Limited.
+ * Copyright 2023 51 Degrees Mobile Experts Limited, Davidson House,
+ * Forbury Square, Reading, Berkshire, United Kingdom RG1 3EU.
+ *
+ * This Original Work is licensed under the European Union Public Licence
+ * (EUPL) v.1.2 and is subject to its terms as set out below.
+ *
+ * If a copy of the EUPL was not distributed with this file, You can obtain
+ * one at https://opensource.org/licenses/EUPL-1.2.
+ *
+ * The 'Compatible Licences' set out in the Appendix to the EUPL (as may be
+ * amended by the European Commission) shall be deemed incompatible for
+ * the purposes of the Work and the provisions of the compatibility
+ * clause in Article 5 of the EUPL shall not apply.
+ *
+ * If using the Work as, or as part of, a network application, by
+ * including the attribution notice(s) required under Article 5 of the EUPL
+ * in the end user terms of the application under an appropriate heading,
+ * such notice(s) shall fulfill the requirements of that article.
  * ********************************************************************* */
 
 const crypto = require('crypto');
@@ -25,6 +25,10 @@ const crypto = require('crypto');
 const FlowElement = require('./flowElement.js');
 const BasicListEvidenceKeyFilter = require('./basicListEvidenceKeyFilter');
 
+/**
+ * @typedef {import('./flowData')} FlowData
+ */
+
 /**
  * The SequenceElement stores session data regarding requests
  * for client side JavaScript from the JavaScript created by a

package/tsconfig.json

@@ -1,21 +1,22 @@
 {
-    // Change this to match your project
-    "include": ["*"],
-    "compilerOptions": {
-      // Tells TypeScript to read JS files, as
-      // normally they are ignored as source files
-      "allowJs": true,
-      // Generate d.ts files
-      "declaration": true,
-      // This compiler run should
-      // only output d.ts files
-      "emitDeclarationOnly": true,
-      // Types should go into this directory.
-      // Removing this would place the .d.ts files
-      // next to the .js files
-      "outDir": "types",
-      "lib": ["ES2015"],
-      "moduleResolution": "Node",
-      "noImplicitAny": true
-    }
-  }
+  // Change this to match your project
+  "include": ["*"],
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    // Tells TypeScript to read JS files, as
+    // normally they are ignored as source files
+    "allowJs": true,
+    // Generate d.ts files
+    "declaration": true,
+    // This compiler run should
+    // only output d.ts files
+    "emitDeclarationOnly": true,
+    // Types should go into this directory.
+    // Removing this would place the .d.ts files
+    // next to the .js files
+    "outDir": "types",
+    "lib": ["ES2015"],
+    "moduleResolution": "Node",
+    "noImplicitAny": true
+  }
+}

package/types/aspectPropertyValue.d.ts

@@ -9,7 +9,7 @@ declare class AspectPropertyValue {
      * Constructor for AspectPropertyValue
      *
      * @param {string} noValueMessage The message to show when no value is set
-     * @param {Mixed} value The value inside the wrapper
+     * @param {*} value The value inside the wrapper
      */
     constructor(noValueMessage: string, value: any);
     noValueMessage: string;
@@ -18,13 +18,13 @@ declare class AspectPropertyValue {
     /**
      * Set the value of this instance.
      *
-     * @param {Mixed} value the value to set
+     * @param {*} value the value to set
      */
-    set value(arg: any);
+    set value(value: any);
     /**
      * Get the value of this instance.
      *
-     * @returns {Mixed} The value of the property
+     * @returns {*} The value of the property
      * @throws Will throw error if 'hasValue' is false.
      */
     get value(): any;

package/types/constants.d.ts

@@ -0,0 +1,2 @@
+export let evidenceEnableCookies: string;
+export let evidenceObjectName: string;

package/types/elementData.d.ts

@@ -1,6 +1,7 @@
 export = ElementData;
 /**
  * @typedef {import('./flowElement')} FlowElement
+ * @typedef {import('./flowData')} FlowData
  */
 /**
  * Stores information created by a flowElement based on flowData.
@@ -31,9 +32,9 @@ declare class ElementData {
      * (or skipping) the getInternal method
      *
      * @param {string} key the key to retrieve a property value for
-     * @returns {mixed} value
+     * @returns {FlowData} value
      */
-    get(key: string): any;
+    get(key: string): FlowData;
     /**
      * Return string value of property
      *
@@ -45,18 +46,19 @@ declare class ElementData {
      * Return float value of property
      *
      * @param {string} key the key to retreive a property value for
-     * @returns {number} value
+     * @returns {number} float value
      */
     getAsFloat(key: string): number;
     /**
      * Return int value of property
      *
      * @param {string} key the key to retreive a property value for
-     * @returns {number} value
+     * @returns {number} int value
      */
     getAsInteger(key: string): number;
 }
 declare namespace ElementData {
-    export { FlowElement };
+    export { FlowElement, FlowData };
 }
-type FlowElement = import('./flowElement');
+type FlowElement = import("./flowElement");
+type FlowData = import("./flowData");

package/types/elementDataDictionary.d.ts

@@ -19,9 +19,17 @@ declare class ElementDataDictionary extends ElementData {
         contents: object;
     }, ...args: any[]);
     contents: object;
+    /**
+     * Return value from elementData dictionary
+     *
+     * @param {string} key the property key to retrieve
+     * @returns {number} integer value
+     */
+    getInternal(key: string): number;
+    [Symbol.iterator](): Generator<string, void, unknown>;
 }
 declare namespace ElementDataDictionary {
     export { FlowElement };
 }
 import ElementData = require("./elementData");
-type FlowElement = import('./flowElement');
+type FlowElement = import("./flowElement");

package/types/errorMessages.d.ts

@@ -1,3 +1,3 @@
-export const noElementData: string;
-export const genericMissingProperties: string;
-export const noReasonUnknown: string;
+export let noElementData: string;
+export let genericMissingProperties: string;
+export let noReasonUnknown: string;

package/types/evidence.d.ts

@@ -18,7 +18,7 @@ declare class Evidence {
      * Add a piece of evidence to flowData
      *
      * @param {string} key evidence key to add
-     * @param {Mixed} value value of evidence key
+     * @param {*} value value of evidence key
      */
     add(key: string, value: any): void;
     /**
@@ -26,7 +26,7 @@ declare class Evidence {
      *
      * @param {object} evidenceObject key value map of evidence
      * @param {string} evidenceObject.key evidencekey
-     * @param {Mixed} evidenceObject.value evidence value
+     * @param {*} evidenceObject.value evidence value
      */
     addObject(evidenceObject: {
         key: string;
@@ -38,14 +38,14 @@ declare class Evidence {
      * headers, cookies, protocol, IP and query params
      *
      * @param {object} request an HTTP request object
-     * @returns {undefined}
+     * @returns {Evidence} return updated evidence
      */
-    addFromRequest(request: object): undefined;
+    addFromRequest(request: object): Evidence;
     /**
      * Get a piece of evidence
      *
      * @param {string} key evidence key to retreive
-     * @returns {mixed} the evidence value
+     * @returns {*} the evidence value
      */
     get(key: string): any;
     /**
@@ -58,4 +58,4 @@ declare class Evidence {
 declare namespace Evidence {
     export { FlowData };
 }
-type FlowData = import('./flowData');
+type FlowData = import("./flowData");

package/types/flowData.d.ts

@@ -38,7 +38,7 @@ declare class FlowData {
      * Set an error on the flowData (usually triggered by
      * something going wrong in a flowElement's process function)
      *
-     * @param {mixed} error the error to throw
+     * @param {*} error the error to throw
      * @param {FlowElement} flowElement the FlowElement the error is thrown on
      */
     setError(error: any, flowElement: FlowElement): void;
@@ -86,6 +86,6 @@ declare namespace FlowData {
     export { Pipeline, FlowElement, ElementData };
 }
 import Evidence = require("./evidence");
-type FlowElement = import('./flowElement');
-type ElementData = import('./elementData');
-type Pipeline = import('./pipeline');
+type Pipeline = import("./pipeline");
+type FlowElement = import("./flowElement");
+type ElementData = import("./elementData");

package/types/flowElement.d.ts

@@ -2,6 +2,7 @@ export = FlowElement;
 /**
  * @typedef {import('./flowData')} FlowData
  * @typedef {import('./pipeline')} Pipeline
+ * @typedef {import('./evidenceKeyFilter')} EvidenceKeyFilter
  */
 /**
  * A FlowElement is placed inside a pipeline
@@ -26,7 +27,7 @@ declare class FlowElement {
         dataKey: string;
         processInternal: Function;
         properties: object;
-        evidenceKeyFilter: any;
+        evidenceKeyFilter: EvidenceKeyFilter;
     });
     dataKey: string;
     /**
@@ -35,13 +36,19 @@ declare class FlowElement {
      * by a pipleline is processsed. Overriden by instances of this base class
      *
      * @param {FlowData} flowData FlowData being processed
-     * @returns {Mixed} result of processing
+     * @returns {*} result of processing
      */
     processInternal(flowData: FlowData): any;
     properties: object;
-    evidenceKeyFilter: any;
-    registrationCallbacks: any[];
-    pipelines: any[];
+    evidenceKeyFilter: EvidenceKeyFilterBase;
+    /**
+     * @type {Function[]}
+     */
+    registrationCallbacks: Function[];
+    /**
+     * @type {Pipeline[]}
+     */
+    pipelines: Pipeline[];
     /**
      * Internal function to be called when a FlowElement is added
      * to pipeline, runs through any registrationCallbacks on the FlowElement
@@ -54,7 +61,8 @@ declare class FlowElement {
     /**
      * Function called to check if a FlowElement is ready
      * Used when there are asynchronous initialisation steps
-     * @returns {Promise}
+     *
+     * @returns {Promise} returns Promise
      * */
     ready(): Promise<any>;
     /**
@@ -81,9 +89,18 @@ declare class FlowElement {
      * @returns {object} dictionary of properties
      */
     getProperties(): object;
+    /**
+     * Internal log
+     *
+     * @param {string} type log type
+     * @param {*} message message to log
+     */
+    _log(type: string, message: any): void;
 }
 declare namespace FlowElement {
-    export { FlowData, Pipeline };
+    export { FlowData, Pipeline, EvidenceKeyFilter };
 }
-type FlowData = import('./flowData');
-type Pipeline = import('./pipeline');
+import EvidenceKeyFilterBase = require("./evidenceKeyFilter");
+type FlowData = import("./flowData");
+type Pipeline = import("./pipeline");
+type EvidenceKeyFilter = import("./evidenceKeyFilter");

package/types/helpers.d.ts

@@ -1,10 +1,18 @@
 export = Helpers;
+/**
+ * @typedef {import('./flowData')} FlowData
+ */
 declare class Helpers {
     /**
      * Set response headers in the response object (e.g. Accept-CH)
-     * @param response: The response to set the headers in.
-     * @param flowData: A processed FlowData instance to get the response header values
+     *
+     * @param {import('http').ServerResponse} response The response to set the headers in.
+     * @param {FlowData} flowData A processed FlowData instance to get the response header values
      * from.
      */
-    static setResponseHeaders(response: any, flowData: any): void;
+    static setResponseHeaders(response: import("http").ServerResponse, flowData: FlowData): void;
 }
+declare namespace Helpers {
+    export { FlowData };
+}
+type FlowData = import("./flowData");

package/types/index.d.ts

@@ -1,15 +1,24 @@
-export const BasicListEvidenceKeyFilter: typeof import("./basicListEvidenceKeyFilter");
-export const ElementData: typeof import("./elementData");
-export const ElementDataDictionary: typeof import("./elementDataDictionary");
-export const Evidence: typeof import("./evidence");
-export const EvidenceKeyFilter: typeof import("./evidenceKeyFilter");
-export const FlowData: typeof import("./flowData");
-export const FlowElement: typeof import("./flowElement");
-export const Pipeline: typeof import("./pipeline");
-export const PipelineBuilder: typeof import("./pipelineBuilder");
-export const AspectPropertyValue: typeof import("./aspectPropertyValue");
-export const JsonBundler: typeof import("./jsonbundler");
-export const JavascriptBuilder: typeof import("./javascriptbuilder");
-export const SequenceElement: typeof import("./sequenceElement");
-export const SetHeadersElement: typeof import("./setHeadersElement");
-export const Helpers: typeof import("./helpers");
+export let BasicListEvidenceKeyFilter: typeof import("./basicListEvidenceKeyFilter");
+export let ElementData: typeof import("./elementData");
+export let ElementDataDictionary: typeof import("./elementDataDictionary");
+export let ErrorMessages: {
+    noElementData: string;
+    genericMissingProperties: string;
+    noReasonUnknown: string;
+};
+export let Constants: {
+    evidenceEnableCookies: string;
+    evidenceObjectName: string;
+};
+export let Evidence: typeof import("./evidence");
+export let EvidenceKeyFilter: typeof import("./evidenceKeyFilter");
+export let FlowData: typeof import("./flowData");
+export let FlowElement: typeof import("./flowElement");
+export let Pipeline: typeof import("./pipeline");
+export let PipelineBuilder: typeof import("./pipelineBuilder");
+export let AspectPropertyValue: typeof import("./aspectPropertyValue");
+export let JsonBundler: typeof import("./jsonbundler");
+export let JavascriptBuilder: typeof import("./javascriptbuilder");
+export let SequenceElement: typeof import("./sequenceElement");
+export let SetHeadersElement: typeof import("./setHeadersElement");
+export let Helpers: typeof import("./helpers");

package/types/javascriptbuilder.d.ts

@@ -26,7 +26,10 @@ declare class JavaScriptBuilderElement extends FlowElement {
      * callback url. This can be overriden with header.host evidence.
      * @param {string} options.endPoint The endpoint of the client side
      * callback url
-     * @param {boolean} options.enableCookies whether cookies should be enabled
+     * @param {boolean} options.enableCookies Whether the client JavaScript
+     * stored results of client side processing in cookies. This can also
+     * be set per request, using the "query.fod-js-enable-cookies" evidence key.
+     * For more details on personal data policy, see http://51degrees.com/terms/client-services-privacy-policy/
      * @param {boolean} options.minify Whether to minify the JavaScript
      */
     constructor({ objName, protocol, host, endPoint, enableCookies, minify }?: {
@@ -45,5 +48,31 @@ declare class JavaScriptBuilderElement extends FlowElement {
         enableCookies: boolean;
         minify: boolean;
     };
+    evidenceKeyFilter: JSEvidenceKeyFilter;
+    /**
+     * Internal process function of the JavaScript builder
+     * Gets JSON from the JSONBundler and constructs JavaScript
+     * to place on the client side
+     *
+     * @param {FlowData} flowData to process
+     * @returns {undefined}
+     */
+    processInternal(flowData: FlowData): undefined;
+}
+declare namespace JavaScriptBuilderElement {
+    export { FlowData };
 }
 import FlowElement = require("./flowElement.js");
+/**
+ * @typedef {import('./flowData')} FlowData
+ */
+/**
+ * An instance of EvidenceKeyFilter which removes all but header
+ * and query evidence as that is all that is used by
+ * the JavaScript builder
+ **/
+declare class JSEvidenceKeyFilter extends EvidenceKeyFilter {
+    filterEvidenceKey(key: any): boolean;
+}
+type FlowData = import("./flowData");
+import EvidenceKeyFilter = require("./evidenceKeyFilter.js");

package/types/jsonbundler.d.ts

@@ -10,6 +10,18 @@ export = JSONBundlerElement;
  */
 declare class JSONBundlerElement extends FlowElement {
     constructor(...args: any[]);
+    evidenceKeyFilter: BasicListEvidenceKeyFilter;
     propertyCache: {};
+    /**
+     * The JSON Builder extracts all properties and serializes them into JSON
+     *
+     * @param {FlowData} flowData the FlowData being processed
+     */
+    processInternal(flowData: FlowData): void;
+}
+declare namespace JSONBundlerElement {
+    export { FlowData };
 }
 import FlowElement = require("./flowElement.js");
+import BasicListEvidenceKeyFilter = require("./basicListEvidenceKeyFilter.js");
+type FlowData = import("./flowData");

package/types/pipeline.d.ts

@@ -1,6 +1,7 @@
 export = Pipeline;
 /**
  * @typedef {import('./flowElement')} FlowElement
+ * @typedef {import('fiftyone.pipeline.engines').DataFileUpdateService} DataFileUpdateService
  */
 /**
  * Pipeline holding a list of flowElements for processing, can create
@@ -13,12 +14,27 @@ declare class Pipeline {
      *
      * @param {FlowElement[]} flowElements list of FlowElements to
      * add to the Pipeline
+     * @param {boolean} suppressProcessExceptions If true then pipeline
+     * will suppress exceptions added to FlowData.
+     * @param {DataFileUpdateService} dataFileUpdateService Service that registers FlowElements
      */
-    constructor(flowElements?: FlowElement[]);
+    constructor(flowElements?: FlowElement[], suppressProcessExceptions?: boolean, dataFileUpdateService?: DataFileUpdateService);
     flowElementsChain: import("./flowElement")[];
+    suppressProcessExceptions: boolean;
+    /**
+     * A logger for emitting messages
+     * @type {EventEmitter}
+     */
     eventEmitter: EventEmitter;
-    flowElements: {};
-    propertyDatabase: {};
+    /**
+     * @type {object}
+     */
+    flowElements: object;
+    dataFileUpdateService: any;
+    /**
+     * @type {object}
+     */
+    propertyDatabase: object;
     processMethod: (flowData: any) => any;
     /**
      * get a FlowElement by its dataKey
@@ -39,7 +55,7 @@ declare class Pipeline {
      * Shorthand to trigger a message on the pipeline's eventEmitter
      *
      * @param {string} type type of message
-     * @param {mixed} message message to store in the log
+     * @param {*} message message to store in the log
      */
     log(type: string, message: any): void;
     /**
@@ -51,15 +67,17 @@ declare class Pipeline {
      */
     createFlowData(): FlowData;
     /**
+     *  Update pipeline's property database for FlowElement
      *
-     * @param {FlowElement} flowElement
+     * @param {FlowElement} flowElement FlowElement to update
      * @returns {void}
      */
     updatePropertyDataBaseForElement(flowElement: FlowElement): void;
 }
 declare namespace Pipeline {
-    export { FlowElement };
+    export { FlowElement, DataFileUpdateService };
 }
 import EventEmitter = require("events");
-type FlowElement = import('./flowElement');
 import FlowData = require("./flowData");
+type FlowElement = import("./flowElement");
+type DataFileUpdateService = any;

package/types/pipelineBuilder.d.ts

@@ -22,19 +22,20 @@ declare class PipelineBuilder {
      * @param {boolean} settings.useSetHeaderProperties Whether to
      * automatically add the SetHeadersElement needed to request additional
      * HTTP headers from the client side. This is true by default.
-     * @param {typeof import('./javascriptbuilder').prototype.settings}
-     * settings.javascriptBuilderSettings The settings
-     * to pass to the JavaScriptBuilder. See JavaScriptBuilder class for details.
+     * @param {typeof import('./javascriptbuilder').prototype.settings} settings.javascriptBuilderSettings
+     * The settings to pass to the JavaScriptBuilder.
+     * See JavaScriptBuilder class for details.
      */
     constructor(settings?: {
         addJavaScriptBuilder: boolean;
         useSetHeaderProperties: boolean;
-        javascriptBuilderSettings: typeof import('./javascriptbuilder').prototype.settings;
+        javascriptBuilderSettings: typeof import("./javascriptbuilder").prototype.settings;
     });
     /**
      * @type {FlowElement[]}
      */
     flowElements: FlowElement[];
+    dataFileUpdateService: any;
     addJavaScriptBuilder: boolean;
     javascriptBuilderSettings: {
         objName: string;
@@ -60,6 +61,13 @@ declare class PipelineBuilder {
      * @returns {Pipeline} the constructed pipeline
      */
     buildFromConfiguration(config: object): Pipeline;
+    /**
+     * Add required elements to an existing FlowElement array
+     *
+     * @param {FlowElement[]} flowElements array of elements to add to
+     * @returns {FlowElement[]} resulting array with required elements
+     */
+    addRequiredElements(flowElements: FlowElement[]): FlowElement[];
     /**
      * Internal function used to first check if the
      * JavaScript elements should be added to the pipeline
@@ -104,5 +112,5 @@ declare class PipelineBuilder {
 declare namespace PipelineBuilder {
     export { FlowElement };
 }
-type FlowElement = import('./flowElement');
 import Pipeline = require("./pipeline");
+type FlowElement = import("./flowElement");