@vertigis/workflow 5.31.0

package/esm/Errors.d.ts

@@ -0,0 +1,146 @@
+declare const ActivityError_base: {
+    new (): Error;
+    prototype: Error;
+};
+/** Defines an abstract error for when an activity error has occurred. */
+export declare abstract class ActivityError extends ActivityError_base {
+    /** Indicates the error code. */
+    code: string;
+}
+/** Defines an error that occurs when an activity has been cancelled. */
+export declare class ActivityCancellationError extends ActivityError {
+}
+/** Defines an error that occurs when there is an error executing an activity. */
+export declare class GenericActivityError extends ActivityError {
+    constructor(code?: string, text?: string);
+    /** Indicates the activity that failed. */
+    activityId: number;
+    /** Indicates the inner error. */
+    code: string;
+    /** Indicates the amount of time taken. */
+    elapsed: number;
+    /** Indicates the error was a result of a timeout. */
+    timedOut: boolean;
+    /** Indicates the inner error. */
+    error: any;
+    /** Indicates the inner errors. */
+    errors: Error[];
+    /** Indicates the partial result. */
+    partialResult: any;
+}
+declare const ProgramStartError_base: {
+    new (): Error;
+    prototype: Error;
+};
+/** Defines an error that occurs when there is no starting step given or available. */
+export declare class ProgramStartError extends ProgramStartError_base {
+    code: string;
+}
+declare const UnspecifiedError_base: {
+    new (): Error;
+    prototype: Error;
+};
+/** Defines an error that occurs when there is no starting step given or available. */
+export declare class UnspecifiedError extends UnspecifiedError_base {
+    code: string;
+}
+/** Defines an error that occurs when there is a problem with instantiating an activity handler. */
+export declare class ActivityBindingError extends ActivityError {
+    constructor(id: number, action: string, error?: any);
+    /** Indicates the activity that failed. */
+    activityId: number;
+    /** Indicates the action that failed. */
+    action: string;
+    /** Indicates the underlying error that occurred. */
+    error: any;
+}
+declare const EngineRuntimeError_base: {
+    new (): Error;
+    prototype: Error;
+};
+/** Defines an error that occurs when there is a problem with the workflow engine. */
+export declare class EngineRuntimeError extends EngineRuntimeError_base {
+    constructor(error: any);
+    code: string;
+    error: any;
+}
+declare const ProgramParserError_base: {
+    new (): Error;
+    prototype: Error;
+};
+/** Defines an error that occurs when there is a problem with parsing the workflow program. */
+export declare class ProgramParserError extends ProgramParserError_base {
+    constructor(error: any);
+    code: string;
+    error: any;
+}
+/** Defines an error that occurs when there is a problem evaluating an expression during the execution of a workflow. */
+export declare class ExpressionEvaluationError extends ActivityError {
+    constructor(id: number, inputName: string, expression: string, error?: any);
+    /** Indicates the identifier the failed activity. */
+    activityId: number;
+    /** Indicates the input name of the failed expression. */
+    inputName: string;
+    /** Indicates the expression that failed. */
+    expression: string;
+    /** Indicates the error that failed. */
+    error: any;
+}
+/** Defines an error that occurs when there is a problem parsing an expression during the execution of a workflow. */
+export declare class ExpressionSyntaxError extends ActivityError {
+    constructor(id: number, inputName: string, expression: string, error?: any);
+    /** Indicates the identifier the failed activity. */
+    activityId: number;
+    /** Indicates the input name of the failed expression. */
+    inputName: string;
+    /** Indicates the expression that failed. */
+    expression: string;
+    /** Indicates the error that failed. */
+    error: any;
+}
+/** Defines an error that occurs when there is a problem accesssing the workflow or global scope. */
+export declare class ExpressionAccessorError extends ActivityError {
+    constructor(id: number, accessorName: string, error: any, errors?: Error[]);
+    /** Indicates the identifier the failed activity. */
+    activityId: number;
+    /** Indicates the accessor name within the failed expression. */
+    accessorName: string;
+    /** Indicates the error that failed. */
+    error?: any;
+    /** Indicates the error that failed. */
+    errors?: Error[];
+}
+/** Defines an error that occurs when there is a problem accessing the workflow or global scope. */
+export declare class ActivityActivationError extends ActivityError {
+    constructor(id: number, type: string, error: any);
+    /** Indicates the identifier the failed activity. */
+    activityId: number;
+    /** Indicates the type of the . */
+    type: string;
+    /** Indicates the error that failed. */
+    error?: any;
+}
+/** Defines an error that occurs when there is a failure with an activity. */
+export declare class AggregateActivityError extends ActivityError {
+    constructor(id: number, errors?: Error[]);
+    /** Indicates the identifier the failed activity. */
+    activityId: number;
+    /** Indicates the error that failed. */
+    errors?: Error[];
+}
+/** Defines an error that occurs when there is a problem with an input. */
+export declare class ActivityInputError extends ActivityError {
+    constructor(inputName: string, assertion: string);
+    /** Indicates the assertion for which the input failed. */
+    assertion: string;
+    /** Indicates the input that there was a problem with. */
+    inputName: string;
+}
+/**
+ * Defines an error that occurs when an attempt was made to execute an activity
+ * which has not been implemented by the host application.
+ */
+export declare class ActivityNotImplementedError extends ActivityError {
+    constructor(activityName: string);
+}
+export {};

package/esm/Errors.js

@@ -0,0 +1 @@
+function makeError(){function r(r){r=Error.call(this,r),this.name=r.name,this.message=r.message,this.stack=r.stack}return r.prototype=Error.prototype,r}class ActivityError extends makeError(){}class ActivityCancellationError extends ActivityError{}ActivityCancellationError.prototype.message="[WF: activity cancellation error] The activity was cancelled.",ActivityCancellationError.prototype.code="WF: activity cancellation error";class GenericActivityError extends ActivityError{constructor(r,e){super(),this.code=r||"WF: activity error",this.message="["+this.code+"] "+(e||"Some errors occurred.")}}class ProgramStartError extends makeError(){}ProgramStartError.prototype.code="WF: start error",ProgramStartError.prototype.message="[WF: start error] The given workflow program contains no start point and none was given in the options.";class UnspecifiedError extends makeError(){}UnspecifiedError.prototype.code="WF: unspecified error",UnspecifiedError.prototype.message="[WF: unspecified error] The given workflow program completed with an unspecified error.";class ActivityBindingError extends ActivityError{constructor(r,e,t){super(),this.action=e,this.error=t}}ActivityBindingError.prototype.code="WF: binding error",ActivityBindingError.prototype.message="[WF: binding error] The given workflow program contains some activities which are not valid.";class EngineRuntimeError extends makeError(){constructor(r){super(),this.error=r}}EngineRuntimeError.prototype.code="WF: runtime error",EngineRuntimeError.prototype.message="[WF: runtime error] The workflow engine experienced an internal error.";class ProgramParserError extends makeError(){constructor(r){super(),this.error=r}}ProgramParserError.prototype.code="WF: parser error",ProgramParserError.prototype.message="[WF: parsing error] The given workflow program could not be parsed.";class ExpressionEvaluationError extends ActivityError{constructor(r,e,t,i){super(),this.activityId=r,this.inputName=e,this.expression=t,this.error=i,this.code="WF: expression evaluation error",this.message="["+this.code+"] The given expression could not be evaluated.",t&&(this.message+=' "'+t+'"'),i&&i.message&&(this.message+=" "+i.message)}}class ExpressionSyntaxError extends ActivityError{constructor(r,e,t,i){super(),this.activityId=r,this.inputName=e,this.expression=t,this.error=i,this.code="WF: expression syntax error",this.message="["+this.code+"] The given expression could not be parsed.",t&&(this.message+=' "'+t+'"'),i&&i.message&&(this.message+=" "+i.message)}}class ExpressionAccessorError extends ActivityError{constructor(r,e,t,i){super(),this.activityId=r,this.accessorName=e,this.error=t,this.code="WF: expression accessor error",this.message="["+this.code+"] The requested accessor could not be resolved.",this.error=t,this.errors=i}}class ActivityActivationError extends ActivityError{constructor(r,e,t){super(),this.activityId=r,this.type=e,this.error=t,this.code="WF: activity activation error",this.message="["+this.code+"] The requested facility could not be activated.",this.error=t}}class AggregateActivityError extends ActivityError{constructor(r,e){super(),this.activityId=r,this.code="WF: aggregate error",this.message="["+this.code+"] The activity experienced multiple errors.",this.errors=e}}class ActivityInputError extends ActivityError{constructor(r,e){super(),this.inputName=r,this.assertion=e}}ActivityInputError.prototype.code="WF: activity input error",ActivityInputError.prototype.message="[WF: activity input error] The activity has invalid inputs.";class ActivityNotImplementedError extends ActivityError{constructor(r){super(),this.message=`[WF: activity not implemented] The ${r} activity has not been implemented.`}}ActivityNotImplementedError.prototype.code="WF: activity not implemented";export{ActivityError,ActivityCancellationError,GenericActivityError,ProgramStartError,UnspecifiedError,ActivityBindingError,EngineRuntimeError,ProgramParserError,ExpressionEvaluationError,ExpressionSyntaxError,ExpressionAccessorError,ActivityActivationError,AggregateActivityError,ActivityInputError,ActivityNotImplementedError};

package/esm/Hooks.d.ts

@@ -0,0 +1,29 @@
+import { IFacility } from "./Activator";
+import { IActivityHandler, IActivityContext, Deferrable } from "./IActivityHandler";
+/** Do not reference. */
+export interface IActivityHandlerConstructorWithFacility<T> {
+    new (): IActivityHandlerWithFacility<T>;
+    prototype: IActivityHandlerWithFacility<T>;
+}
+/** Do not reference. */
+export interface IActivityHandlerConstructorWithTwoFacilities<T1, T2> {
+    new (): IActivityHandlerWithTwoFacilities<T1, T2>;
+    prototype: IActivityHandlerWithTwoFacilities<T1, T2>;
+}
+/** Do not reference. */
+export interface IActivityHandlerWithFacility<T> {
+    execute(inputs: {}, context: IActivityContext, facility: T, ...args: any[]): Deferrable<{}>;
+}
+/** Do not reference. */
+export interface IActivityHandlerWithTwoFacilities<T1, T2> {
+    execute(inputs: {}, context: IActivityContext, facility1: T1, facility2: T2, ...args: any[]): Deferrable<{}>;
+}
+/** Decorates activity handlers which require a facility. */
+export declare function activate<T extends IFacility>(basis: T): (target: IActivityHandlerConstructorWithFacility<T>) => void;
+/** Decorates activity handlers which require two facilities. */
+export declare function activateTwo<T1 extends IFacility, T2 extends IFacility>(basis1: T1, basis2: T2): (target: IActivityHandlerConstructorWithTwoFacilities<T1, T2>) => void;
+/**
+ * Discovered facility types previously assigned to the specified handler.
+ * @param handler An activity handler to inspect for associated facilities.
+ */
+export declare function query(handler: IActivityHandler): IFacility[];

package/esm/Hooks.js

@@ -0,0 +1 @@
+const guid="AB6BF11D-6ED6-45F2-8FCB-B9BECC39A905",basisPropertyNam=`${guid}:Basis`,basisTwoPropertyName=`${guid}:BasisTwo`;function activate(t){return function(e){e.prototype.execute[basisPropertyNam]=t}}function activateTwo(t,o){return function(e){e.prototype.execute[basisPropertyNam]=t,e.prototype.execute[basisTwoPropertyName]=o}}function query(e){const t=[];var o=e.execute[basisPropertyNam];return o&&(t.push(o),(e=e.execute[basisTwoPropertyName])&&t.push(e)),t}export{activate,activateTwo,query};

package/esm/IActivityHandler.d.ts

@@ -0,0 +1,89 @@
+import { Task } from "./Task";
+import Bluebird from "./deps/bluebird_fork";
+/** Shorthand for a deferrable result. */
+export declare type Deferrable<T> = PromiseLike<T> | T;
+/** Implemented by activity handlers. */
+export interface IActivityHandler {
+    /** Executes the logic for an activity. */
+    execute(inputs: {}, context: IActivityContext, ...args: any[]): Deferrable<{}>;
+}
+/** Describes ambient-level state. */
+export interface IAmbientState {
+    /** Indicates the ActivityContexts with group name monikers that are in scope. */
+    activityContexts: {};
+    /** Indicates the completion object. */
+    completion: Bluebird<{}>;
+    /** Indicates the environment for expressions evaluation. */
+    environment: {};
+    /** Indicates the resources for expression evaluation. */
+    resources: {};
+    /** Indicates the error given to the workflow consumer. */
+    error: Error;
+    /** Indicates the inputs given to the workflow consumer. */
+    inputs: {};
+    /** Indicates the current workflow locale */
+    locale: string;
+    /** Indicates the outputs that the workflow should return. */
+    outputs: {};
+    /** Indicates the trivia for storing ambient-level state. */
+    trivia: {};
+    /** Immediately completes the workflow. */
+    complete(outputs?: {}): void;
+    /** Immediately completes the workflow with an error. */
+    reject(error?: Error): void;
+}
+/**
+ * Describes something that can be aborted via an `AbortController`.
+ */
+export interface Abortable {
+    /**
+     * An `AbortSignal` to be passed to Esri's web-based APIs.
+     * When aborted, the operation will be cancelled.
+     */
+    signal?: AbortSignal;
+}
+/** Describes an activity currently being executed. */
+export interface IActivityContext {
+    /** Indicates the locally-unique identifier that changes per-run per-activity. */
+    luid: any;
+    /** Indicates the ambient state. */
+    ambient: IAmbientState;
+    /** Indicates the action being executed. */
+    action: string;
+    /** Indicates the branch being executed. */
+    branch: boolean | number | string;
+    /** Indicates the cancellation token. */
+    cancellationToken: Task<void> & Abortable;
+    /** Indicates the number of passes on the current step. */
+    passes: number;
+    /** Indicates the state that was persisted. */
+    state: any;
+    /** Indicates the error that was caught. */
+    caught: Error;
+    /** Attempts to call on a transition chain. */
+    call(branch?: boolean | number | string): void;
+    /** Attempts to fork to a transition chain. */
+    fork(branch?: boolean | number | string): void;
+    /** Attempts to jump to a transition chain. */
+    jump(branch?: boolean | number | string): void;
+    /** Instructs the engine to allow the activity to handle errors. */
+    registerForErrors(): void;
+    /** Indicates if any transitions are available for the given branch. */
+    hasBranch(branch?: boolean | number | string): boolean;
+    /** Persists state across invocations. */
+    persist(state: any): void;
+    /** Attempts to restart the workflow at the context. */
+    goto(): void;
+}
+/**
+ * Indicates an activity has no inputs. Should only be used in
+ * an activity's execute method signature.
+ */
+export interface EmptyInputs {
+}
+/**
+ * Indicates an activity has no outputs. Should only be used in
+ * an activity's execute method signature.
+ */
+export interface EmptyOutputs {
+}

package/esm/LanguageStringUtils.d.ts

@@ -0,0 +1,17 @@
+import { Lookup } from "./Collections";
+import { ProgramInspector } from "./definition/ProgramInspector";
+import { RunOptions } from "./execution/Engine";
+/**
+ * Gets the language strings to be used by the program. These are accumulated from three different places in
+ * the following order:
+ *
+ *   * Firstly, we start with the hard-coded `defaultStrings`.
+ *   * Secondly, any language strings provided by the host application are added.
+ *   * Finally, any language strings defined in the workflow for the specified locale are added.
+ *
+ * In each case, when a language key is already present, the new value replaces the existing one.
+ *
+ * @param inspector The `ProgramInspector` for the workflow being executed.
+ * @param options The `RunOptions` provided by the host application.
+ */
+export declare function getStringsForProgram(inspector: ProgramInspector, options: RunOptions): Lookup<string>;

package/esm/LanguageStringUtils.js

@@ -0,0 +1 @@
+const defaultStrings={"common-all":"All","common-clear":"Clear","common-done":"Done","common-none":"None","common-start":"Start","common-end":"End","file-picker-remove-item-label":"Clear file","form-element-status-failure":"Failure","form-element-status-invalid":"Invalid input","form-element-status-missing":"Required","form-element-status-pending":"Working...","form-element-status-trivial":"No data"};function getStringsForProgram(e,t){const n={...defaultStrings};if(t.strings)for(const r of Object.keys(t.strings))n[r]=t.strings[r];var o=e.getStrings(t.locale);for(const s of Object.keys(o))n[s]=o[s];return n}export{getStringsForProgram};

package/esm/ProgramInspectorFacility.d.ts

@@ -0,0 +1,23 @@
+import { ProgramInspector } from "./definition/ProgramInspector";
+import Bluebird from "./deps/bluebird_fork";
+export interface ResolveArgs {
+    id?: string;
+    program?: string | {};
+    url?: string;
+}
+export declare class ProgramInspectorFacility {
+    private _cache;
+    constructor();
+    /**
+     * Resolves the program inspector for a specified workflow `Program`. This function will cache the workflow program by default
+     * and will return the cached version in subsequent lookups, unless instructed otherwise.
+     * @param args The input `ResolveArgs` argument. Depending on the host, this may be a url or an object containing an id, url or workflow `Program` object.
+     * @param useCache An optional boolean which determines whether caching is allowed for retrieved workflow programs. Defaults to true.
+     * @param workflowDownloader An optional function which may be used to override the default download function for retrieving a workflow `Program`
+     *                           This is useful on hosts like GVH where special processing may be required before downloading resources.
+     */
+    resolveInspector(args: ResolveArgs | string, useCache?: boolean, workflowDownloader?: (url: string) => Bluebird<any>): Bluebird<ProgramInspector>;
+    private downloadAndResolveInspector;
+    private loadWorkflow;
+    private createInspector;
+}

package/esm/ProgramInspectorFacility.js

@@ -0,0 +1 @@
+import esriRequest from"@arcgis/core/request";import{Dictionary}from"./Collections.js";import{ProgramInspector}from"./definition/ProgramInspector.js";import Bluebird from"./deps/bluebird_fork.js";class ProgramInspectorFacility{constructor(){this._cache=new Dictionary}resolveInspector(o,n=!0,i){return Bluebird.attempt(()=>{if(!o)return this.downloadAndResolveInspector(void 0,i);var r="string"==typeof o?o:o.program||o.url;if(n){const t="string"==typeof o?o:o.id||o.url;if(void 0!==t&&null!==t){var e=this._cache.find(t);return void 0!==e?e:(this._cache.assign(t,this.downloadAndResolveInspector(r,i).catch(r=>(this._cache.remove(t),Bluebird.reject(r)))),this._cache.find(t))}}return this.downloadAndResolveInspector(r,i)})}downloadAndResolveInspector(r,e){if(r instanceof ProgramInspector)return Bluebird.resolve(r);if("object"==typeof r)return this.createInspector(r);const t=e||this.loadWorkflow;return t(r).then(this.createInspector).catch(r=>Bluebird.reject(r))}loadWorkflow(r){var e=r.match(/^(.*?)\/home\/item\.html\?id=(.*?)(\#.*)?$/);return null!=e&&(r=`${e[1]}/sharing/rest/content/items/${e[2]}/data?f=json`),Bluebird.resolve(esriRequest(r)).then(r=>Bluebird.resolve(r.data))}createInspector(e){return Bluebird.attempt(function(){if(e instanceof ProgramInspector)return e;const r=new ProgramInspector;return r.import(e),r})}}export{ProgramInspectorFacility};

package/esm/Task.d.ts

@@ -0,0 +1,55 @@
+export declare class Task<T> implements PromiseLike<T> {
+    private _state;
+    private _value;
+    private _reason;
+    private _promise;
+    constructor(executor: (resolve: (value?: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void);
+    static attempt<T>(myFunction: () => T | Task<T>): Task<T>;
+    /**
+     * Creates a Task that is resolved or rejected when any of the provided Tasks are resolved
+     * or rejected.
+     * @param values An array of Tasks.
+     * @returns A new Task.
+     */
+    static race<T>(values: readonly (T | PromiseLike<T>)[]): Task<T>;
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
+     * resolved value cannot be modified from the callback.
+     *
+     * This polyfill is based on a Stack Overflow answer:
+     * https://stackoverflow.com/a/53327815/5322405
+     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): Task<T>;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Task<TResult1 | TResult2>;
+    /**
+     * Returns `true` if the task succeeded, `false` otherwise.
+     */
+    isFulfilled(): boolean;
+    /**
+     * Returns `true` if the task is still running, `false` otherwise.
+     */
+    isPending(): boolean;
+    /**
+     * Returns `true` if the task failed, `false` otherwise.
+     */
+    isRejected(): boolean;
+    /**
+     * Returns `true` if the task's fate has been decided one way or the other.
+     * It is no longer pending.
+     */
+    isResolved(): boolean;
+    /**
+     * Returns the failure object (if any) if the task is rejected.
+     * Otherwise throws an error. Call the `isRejected()` method to confirm
+     * that a Task failed prior to calling this method.
+     */
+    reason(): any;
+    /**
+     * Returns the value (if any) if the task is resolved.
+     * Otherwise throws an error. Call the `isResolved()` method to confirm
+     * that a Task succeeded prior to calling this method.
+     */
+    value(): T;
+}

package/esm/Task.js

@@ -0,0 +1 @@
+const TaskStates={FULFILLED:"fulfilled",PENDING:"pending",REJECTED:"rejected"};class Task{constructor(t){this._promise=new Promise(t),this._state="pending"}static attempt(e){return new Task(t=>{t(e())})}static race(a){return new Task((t,e)=>{for(const s of a)"object"==typeof s&&"function"==typeof s.then?s.then(t,e):t(s)})}finally(e){const s=t=>Promise.resolve(e()).then(t);return this.then(t=>s(()=>t),t=>s(()=>Promise.reject(t)))}then(e,s){const a=t=>(this._state="fulfilled",this._value=t,e(t)),r=t=>(this._state="rejected",this._reason=t,s(t));return new Task(t=>t(this._promise.then(a,r)))}isFulfilled(){return this._state===TaskStates.FULFILLED}isPending(){return this._state===TaskStates.PENDING}isRejected(){return this._state===TaskStates.REJECTED}isResolved(){return this._state!==TaskStates.PENDING}reason(){if(this._state!==TaskStates.REJECTED)throw new Error(`Attempting to read failure reason from a Task that is not rejected. This Task is ${this._state}.`);return this._reason}value(){if(this._state!==TaskStates.FULFILLED)throw new Error(`Attempting to read value from a Task that is not resolved. This Task is ${this._state}.`);return this._value}}export{Task};

package/esm/TemplateUtils.d.ts

@@ -0,0 +1,28 @@
+import { MarkdownRef } from "./forms/FormDefinition";
+export interface TokenInstance {
+    token: string;
+    start: number;
+    end: number;
+}
+export interface TokenValues {
+    [token: string]: string;
+}
+export declare function findTokenInstances(formatString: string): TokenInstance[];
+/**
+ * Gets a string representation of the supplied value.
+ * @param token The name of the token being replaced.
+ * @param value The value to replace the token.
+ */
+export declare function getTokenValueString(token: string, value: any): string;
+export declare function replacePlaceholders(formatString: string, tokenInstances: TokenInstance[], tokenValues: TokenValues): MarkdownRef;
+/**
+ * Returns the value itself, or an empty string if the value is `null` or `undefined`.
+ *
+ * Care must be taken to handle two cases correctly:
+ * 1) A "falsey" value such as zero should be preserved as it is still a legitimate value.
+ * 2) Values of `undefined` and `null` must not be mistakenly interpreted to mean
+ *    "the field name was invalid".
+ * @param value A value to inspect.
+ * @returns The value itself, or an empty string if the value is `null` or `undefined`.
+ */
+export declare function valueOrEmptyString(value: any): any;

package/esm/TemplateUtils.js

@@ -0,0 +1 @@
+function findTokenInstances(n){const t=[];if(!n)return t;const e=/{\s*([^\{\}]*[^\s\{\}])\s*}/gm;let r=e.exec(n);for(;r;){var o=r[1],s=e.lastIndex,a=s-r[0].length;t.push({token:o,start:a,end:s}),r=e.exec(n)}return t}function getTokenValueString(n,t){return void 0===t?`{${n}}`:null===t?"":String(t)}function replacePlaceholders(n,t,e){let r="",o=0;for(const a of t){var s=a.token;if(o>a.start){console.error("Invalid token data. Data must be supplied in order",t),r=n;break}o<a.start&&(r+=n.substring(o,a.start),o=a.start),r+=e[s],o=a.end}return r+=n.substring(o),{markdown:r}}function valueOrEmptyString(n){return null==n?"":n}export{findTokenInstances,getTokenValueString,replacePlaceholders,valueOrEmptyString};

package/esm/Validation.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="arcgis-js-api" />
+import { Lookup } from "./Collections";
+/** An object used to facilitate activity input validation. */
+export declare namespace validation {
+    const never: any;
+    /** Fails an assertion. */
+    function fail(inputName: string, assertion: string): void;
+    /** Coerces an array out of a value. */
+    function array<T>(inputName: string, value: T[] | T, defaultValue?: T[]): T[];
+    /** Checks if the given value is a defined value. */
+    function exists<T>(inputName: string, value: T, defaultValue?: T): T;
+    function id(inputName: string, value: any, defaultValue?: string | number): string | number;
+    /** Checks if the given value is a defined value. */
+    function number(inputName: string, value: any, defaultValue?: number): number;
+    /** Checks if the given value is a defined within a map. */
+    /** This can be useful for coercing enumerations. */
+    function choice<T>(inputName: string, map: Lookup<T>, value: T): T;
+    /** Checks if the given value is a defined within a map. */
+    function boolean(inputName: string, value: any, defaultValue?: boolean): boolean;
+    /** Checks if the given value is a defined within a map. */
+    function string(inputName: string, value: any, defaultValue?: string): string;
+    /** Checks if an input object contains a url or an esri layer with a url. */
+    function urlOrLayer(inputs: {
+        url?: string;
+        layer?: __esri.Layer;
+    }): string;
+}

package/esm/Validation.js

@@ -0,0 +1 @@
+import{ActivityInputError}from"./Errors.js";var validation;!function(i){function l(r,n){throw new ActivityInputError(r,n)}i.never={},i.fail=l,i.array=function(r,n,e){return null==n?(e===i.never&&l(r,"array"),2<arguments.length?e:void 0):n instanceof Array?n:[n]},i.exists=function(r,n,e){return null!=n?n:2<arguments.length?e:void l(r,"exists")},i.id=function(r,n,e){return null==n?(e===i.never&&l(r,"id"),2<arguments.length?e:void 0):"string"==typeof n||"number"==typeof n&&0*n==0?n:2<arguments.length?(e===i.never&&l(r,"id"),e):void l(r,"number")},i.number=function(r,n,e){if(null==n)return e===i.never&&l(r,"number"),2<arguments.length?e:void 0;var t=n.valueOf();if("number"==typeof t)return t;if("boolean"==typeof t)return t?1:0;if("string"==typeof t){t=parseFloat(n);if(!isNaN(t))return t}if(2<arguments.length)return e===i.never&&l(r,"number"),e;l(r,"number")},i.choice=function(r,n,e){if(null!=e){e=n[e.toString()];if(null==e)return e;l(r,"choice")}},i.boolean=function(r,n,e){return null==n?(e===i.never&&l(r,"boolean"),2<arguments.length?e:void 0):"boolean"==typeof n?n:2<arguments.length?(e===i.never&&l(r,"boolean"),e):void l(r,"boolean")},i.string=function(r,n,e){return null==n?(e===i.never&&l(r,"string"),2<arguments.length?e:void 0):"string"==typeof n?n:2<arguments.length?(e===i.never&&l(r,"string"),e):void l(r,"string")},i.urlOrLayer=function(n){if(null!=n){let r=n.url;n=n.layer;if(!r&&n&&n.url&&(r=void 0!==n.layerId&&null!==n.layerId?`${n.url}/${n.layerId}`:n.url),r)return r}l("url or layer","url or layer input is required. layer must have a valid url property.")}}(validation=validation||{});export{validation};

package/esm/activities/app/GetApplicationData.d.ts

@@ -0,0 +1,12 @@
+import { IActivityHandler } from "../../IActivityHandler";
+export interface GetApplicationDataInputs {
+    key: string;
+}
+export interface GetApplicationDataOutputs {
+    value: any;
+}
+export declare class GetApplicationData implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: GetApplicationDataInputs): Promise<GetApplicationDataOutputs>;
+}

package/esm/activities/app/GetApplicationData.js

@@ -0,0 +1 @@
+import{validation}from"../../Validation.js";import{WFStorage}from"./constants.js";class GetApplicationData{async execute(t){t=validation.string("key",t.key,validation.never);let a;return document[WFStorage]&&(a=document[WFStorage][t]),{value:a}}}GetApplicationData.action="gcx:wf:app::GetApplicationData",GetApplicationData.suite="gcx:wf:builtin";export{GetApplicationData};

package/esm/activities/app/GetApplicationInfo.d.ts

@@ -0,0 +1,12 @@
+import { EmptyInputs, IActivityHandler } from "../../IActivityHandler";
+/** Defines outputs from the GetApplicationInfo activity. */
+export interface GetApplicationInfoOutputs {
+    name: string;
+    version?: string;
+    info: any;
+}
+export declare class GetApplicationInfo implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: EmptyInputs): GetApplicationInfoOutputs;
+}

package/esm/activities/app/GetApplicationInfo.js

@@ -0,0 +1 @@
+class GetApplicationInfo{execute(n){return{name:"Unknown",version:void 0,info:{}}}}GetApplicationInfo.action="gcx:wf:app::GetApplicationInfo",GetApplicationInfo.suite="gcx:wf:builtin";export{GetApplicationInfo};

package/esm/activities/app/GetUserInfo.d.ts

@@ -0,0 +1,12 @@
+import { IActivityHandler, EmptyInputs } from "../../IActivityHandler";
+/** Defines outputs from the GetUserInfo activity. */
+export interface GetUserInfoOutputs {
+    username: string;
+    email: string;
+    roles: string[];
+}
+export declare class GetUserInfo implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: EmptyInputs): GetUserInfoOutputs;
+}

package/esm/activities/app/GetUserInfo.js

@@ -0,0 +1 @@
+import{ActivityNotImplementedError}from"../../Errors.js";class GetUserInfo{execute(e){throw new ActivityNotImplementedError(GetUserInfo.action)}}GetUserInfo.action="gcx:wf:app::GetUserInfo",GetUserInfo.suite="gcx:wf:builtin";export{GetUserInfo};

package/esm/activities/app/PublishEvent.d.ts

@@ -0,0 +1,14 @@
+import { IActivityHandler, EmptyOutputs } from "../../IActivityHandler";
+/** Inputs for the PublishEvent activity. */
+export interface PublishEventInputs {
+    /** The name of the event to publish. */
+    eventName: string;
+    /** The event argument data to publish. */
+    eventArgument?: any;
+}
+/** Activity which publishes a named event in the host application. */
+export declare class PublishEvent implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: PublishEventInputs): EmptyOutputs;
+}

package/esm/activities/app/PublishEvent.js

@@ -0,0 +1 @@
+import{ActivityNotImplementedError}from"../../Errors.js";class PublishEvent{execute(t){throw new ActivityNotImplementedError(PublishEvent.action)}}PublishEvent.action="gcx:wf:app::PublishEvent",PublishEvent.suite="gcx:wf:builtin";export{PublishEvent};

package/esm/activities/app/RemoveApplicationData.d.ts

@@ -0,0 +1,11 @@
+export interface RemoveApplicationDataInputs {
+    key: string;
+}
+export interface RemoveApplicationDataOutputs {
+    removed: boolean;
+}
+export declare class RemoveApplicationData {
+    static action: string;
+    static suite: string;
+    execute(inputs: RemoveApplicationDataInputs): Promise<RemoveApplicationDataOutputs>;
+}

package/esm/activities/app/RemoveApplicationData.js

@@ -0,0 +1 @@
+import{validation}from"../../Validation.js";import{WFStorage}from"./constants.js";class RemoveApplicationData{async execute(e){e=validation.string("key",e.key,validation.never);return document[WFStorage]&&void 0!==document[WFStorage][e]?{removed:delete document[WFStorage][e]}:{removed:!1}}}RemoveApplicationData.action="gcx:wf:app::RemoveApplicationData",RemoveApplicationData.suite="gcx:wf:builtin";export{RemoveApplicationData};

package/esm/activities/app/RunCommand.d.ts

@@ -0,0 +1,14 @@
+import { IActivityHandler, IActivityContext, EmptyOutputs } from "../../IActivityHandler";
+/** Inputs for the RunCommand activity. */
+export interface RunCommandInputs {
+    /** The name of the command to invoke. */
+    commandName: string;
+    /** The parameter to pass to the command. */
+    commandParameter?: any;
+}
+/** Activity which runs a named command in the host application. */
+export declare class RunCommand implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: RunCommandInputs, context: IActivityContext): EmptyOutputs;
+}

package/esm/activities/app/RunCommand.js

@@ -0,0 +1 @@
+import{ActivityNotImplementedError}from"../../Errors.js";class RunCommand{execute(m,n){throw new ActivityNotImplementedError(RunCommand.action)}}RunCommand.action="gcx:wf:app::RunCommand",RunCommand.suite="gcx:wf:builtin";export{RunCommand};

package/esm/activities/app/RunOperation.d.ts

@@ -0,0 +1,19 @@
+import { IActivityHandler, IActivityContext } from "../../IActivityHandler";
+/** Inputs for the RunOperation activity. */
+export interface RunOperationInputs {
+    /** The name of the operation to invoke. */
+    operationName: string;
+    /** The parameter to pass to the operation. */
+    operationParameter?: any;
+}
+/** Outputs for the RunOperation activity. */
+export interface RunOperationOutputs {
+    /** The result of the operation. */
+    result: any;
+}
+/** Activity which runs a named operation in the host application. */
+export declare class RunOperation implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: RunOperationInputs, context: IActivityContext): RunOperationOutputs;
+}

package/esm/activities/app/RunOperation.js

@@ -0,0 +1 @@
+import{ActivityNotImplementedError}from"../../Errors.js";class RunOperation{execute(t,r){throw new ActivityNotImplementedError(RunOperation.action)}}RunOperation.action="gcx:wf:app::RunOperation",RunOperation.suite="gcx:wf:builtin";export{RunOperation};

package/esm/activities/app/SetApplicationData.d.ts

@@ -0,0 +1,10 @@
+import { IActivityHandler, EmptyOutputs } from "../../IActivityHandler";
+export interface SetApplicationDataInputs {
+    key: string;
+    value: any;
+}
+export declare class SetApplicationData implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: SetApplicationDataInputs): EmptyOutputs;
+}

package/esm/activities/app/SetApplicationData.js

@@ -0,0 +1 @@
+import{validation}from"../../Validation.js";import{WFStorage}from"./constants.js";class SetApplicationData{execute(t){var a=validation.string("key",t.key,validation.never);return document[WFStorage]||(document[WFStorage]={}),document[WFStorage][a]=t.value,{}}}SetApplicationData.action="gcx:wf:app::SetApplicationData",SetApplicationData.suite="gcx:wf:builtin";export{SetApplicationData};

package/esm/activities/app/constants.d.ts

@@ -0,0 +1 @@
+export declare const WFStorage = "__WFStorage__";

package/esm/activities/app/constants.js

@@ -0,0 +1 @@
+const WFStorage="__WFStorage__";export{WFStorage};

package/esm/activities/arcgis/AddAttachment.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="arcgis-js-api" />
+import { IActivityHandler, IActivityContext, Deferrable } from "../../IActivityHandler";
+export interface AddAttachmentInputs {
+    /** The URL of the ArcGIS feature layer or table. Either url or layer is required. */
+    url?: string;
+    /** The ArcGIS feature layer or table. Either url or layer is required. */
+    layer?: __esri.Layer;
+    objectId: number;
+    attachment: File;
+    /** The geodatabase version on which the operation will be performed. This argument only applies to layers or tables that support versioned data. Requires ArcGIS Server v.10.1+. */
+    gdbVersion?: string;
+    /** The time span in milliseconds to wait for the request's results. */
+    timeout?: number;
+}
+export interface AddAttachmentOutputs {
+    result: any;
+}
+/** Add an attachment to the feature specified by the object id. */
+export declare class AddAttachment implements IActivityHandler {
+    static action: string;
+    static suite: string;
+    execute(inputs: AddAttachmentInputs, context: IActivityContext): Deferrable<AddAttachmentOutputs>;
+}