archiyou 0.7.0

package/dist/src/Runner.d.ts

@@ -0,0 +1,230 @@
+import { ArchiyouApp, Statement, StatementResult, RunnerScriptScopeState, ScriptOutputFormat, ScriptOutputData, RunnerScriptExecutionResult, Script, Pipeline, RunnerRole, RunnerScriptExecutionRequest, RunnerActiveScope, RunnerWorkerMessage, RunnerManagerMessage, ScriptParamData } from './internal';
+export declare class Runner {
+    ay: ArchiyouApp;
+    role: RunnerRole;
+    _config: Record<string, any>;
+    _oc: any;
+    _localScopes: Record<string, any>;
+    _activeScope: RunnerActiveScope;
+    _activeExecRequest: RunnerScriptExecutionRequest;
+    _componentScripts: Record<string, Script>;
+    _pipelines: Array<Pipeline>;
+    _pipelineExports: Array<any>;
+    _manageWorker: Worker | null;
+    _onWorkerMessageFunc: (m: RunnerWorkerMessage) => any;
+    LOGGING_DEBUG: boolean;
+    DEFAULT_ROLE: RunnerRole;
+    DEFAULT_OUTPUTS: string[];
+    OUTPUT_FORMAT_DEFAULTS: Record<ScriptOutputFormat, Record<string, any>>;
+    /**
+     *  Create a new Runner instance on main thread (as manager or single)
+     *  Or as parallel worker (Webworker or WorkerThread) listening to incoming messages before doing the work
+     */
+    constructor(role?: RunnerRole);
+    /** Loading Archiyou library with WASM module
+        @returns [Runner, OC library]
+    */
+    load(): Promise<this>;
+    /** If OpenCascade is loaded */
+    loaded(): boolean;
+    startAsManager(worker?: Worker, settings?: Record<string, any>): this;
+    /** Supply a function to call when we get a message from the Worker */
+    onWorkerMessage(func: (message: RunnerWorkerMessage) => any): this;
+    /** Send message to Worker
+     * IMPORTANT: data can only contain standard data types (no functions, classes etc)
+     */
+    _postMessageToWorker(message: RunnerManagerMessage): void;
+    /** Setup communication between manager and worker */
+    _connectToWorker(settings?: Record<string, any>): void;
+    _handleMessageFromWorker(m: MessageEvent): void;
+    /** Set current runner as worker wihtin a parallel thread
+     *  Listen to messages on ports, execute scripts and send back the results
+     */
+    _startAsWorker(): this;
+    _startWorkerListener(): any;
+    /** Post message as worker to parent
+     *  IMPORTANT: data can only contain standard data types (no functions, classes etc)
+    */
+    _postMessageToManager(message: RunnerWorkerMessage): void;
+    _handleMessageFromManager(e: MessageEvent): Promise<void>;
+    _getWorkerContext(): globalThis | null;
+    _getWorkerThreadContext(): null;
+    _getWorkerContextName(): 'webworker' | 'workerthread';
+    /** Set Execution Scope
+     *  Depending on the execution context we set up a scope in which the script will run
+     *
+     *  NOTES:
+     *      - big errors like 'var Module=typeof Module!="undefined"?Module:{}....' are ofter thrown when any problem arrises
+     *
+     * */
+    createScope(name?: string): this;
+    /** Build start Archiyou state for a execution scope
+     *  Each scope uses its own instances of Archiyou modules
+     */
+    buildLocalExecScopeState(): RunnerScriptScopeState;
+    /** Initiate all Archiyou modules and return a state object
+     *  that is plugged into a local execution scope
+     */
+    initLocalArchiyou(): ArchiyouApp;
+    /** Our scopes are very limited. We need to make sure basic globals are availble */
+    _addGlobalsToScopeState(state: Record<string, any>): Record<string, any>;
+    /** Add Archiyou modules as globals in execution scope state object */
+    _addModulesToScopeState(state: Record<string, any>): Record<string, any>;
+    _addLoggingToScopeState(state: Record<string, any>): Record<string, any>;
+    /** Make general modeling methods available in scope state object */
+    _addModelingMethodsToScopeState(state: Record<string, any>): Record<string, any>;
+    /** Add specific meta methods */
+    _addMetaMethodsToScopeState(state: Record<string, any>): void;
+    /** Make a new pipeline. Use .do(fn) to set function later */
+    pipeline(name?: string, fn?: () => any): Pipeline;
+    getPipelineNames(): Array<string>;
+    getPipelineByName(name: string): Pipeline;
+    /** Select a scope */
+    scope(name: string): this;
+    getLocalActiveScope(): RunnerScriptScopeState;
+    getLocalScope(name: string): RunnerScriptScopeState;
+    deleteLocalScope(name: string): this;
+    /** Start execution of entire code or script with params in fresh, active scope
+     *  @request - string with code or object with script and params
+     *  @result - return the result of the execution
+    */
+    execute(request: string | RunnerScriptExecutionRequest): Promise<RunnerScriptExecutionResult>;
+    /** Execute (entire or partial) request on local execution scope or on managed worker */
+    private _execute;
+    /** Main entrypoint for execution in statements
+     *  Use this is you need more control of execution and possible errors
+     *  This seperates the code in statements and returns results for each statement
+     *  It still uses execute() internally
+    */
+    executeInStatements(request: RunnerScriptExecutionRequest): Promise<RunnerScriptExecutionResult>;
+    /** Check execution request */
+    _checkRequestAndAddDefaults(request: RunnerScriptExecutionRequest): RunnerScriptExecutionRequest;
+    /** Check params in RunnerScriptExecutionRequest
+     *  We need to make sure that param values are there and consistent with param definitions
+     *  - if param values (request.params) are not set, we use default values from script.params definitions
+     *  - param values (request.params) are put in defs (request.script.params)
+     *
+     *  TODO: Use ScriptParam.validateValue() to validate incoming values
+     *
+     * */
+    _checkRequestParams(request: RunnerScriptExecutionRequest): RunnerScriptExecutionRequest;
+    /** Execute a request in a seperate managed worker */
+    _executeInWorker(request: RunnerScriptExecutionRequest): Promise<RunnerScriptExecutionResult>;
+    /** Execute a piece of code or script (and params) in local execution context
+     *  @param {RunnerScriptExecutionRequest} [request] - string with code or object with script and params
+     *  @param {boolean} [startRun] - if true a reset is made of the state to prepare for fresh run
+     *  @param {boolean} [output] - if true, the Archiyou state is returned as RunnerScriptExecutionResult
+     *
+     *  @returns - RunnerScriptExecutionResult or error string or null if no output
+     *
+     *  NOTE: this = execution context (not Runner)
+    */
+    _executeLocal(request: RunnerScriptExecutionRequest, startRun?: boolean, output?: boolean): Promise<RunnerScriptExecutionResult | null>;
+    _handleExecutionError(scope: RunnerScriptScopeState, request: RunnerScriptExecutionRequest, code: string, e: Error): RunnerScriptExecutionResult;
+    _extractScriptContextFromErrorStack(e: Error, code: string): string | null;
+    /** Run a execution request (with script, params etc) in individual statements
+     *  This is used for debugging and testing in browser
+     *  NOTE: see executeInStatements() for main entrypoint
+    */
+    _executeLocalInStatements(request: RunnerScriptExecutionRequest, statementResults: Array<StatementResult>): Promise<RunnerScriptExecutionResult>;
+    /** Some preprocessing for statements */
+    _preprocessStatement(statement: Statement): Statement;
+    /** Setup for every execution run inside execution scope
+     *  IMPORTANT: 'this' is the execution scope
+    */
+    _executionStartRunInScope(scope: any, request: RunnerScriptExecutionRequest): void;
+    /** Execute a component script in a seperate scope
+     *  This is always done in local context
+     *   because executing components comes from within execution scope and context
+     *   IMPORTANT:
+     *      - We want to avoid writing in a script: await $component('name').get(..)
+     *          which will be ugly and prone to errors
+     *      - So a sync function is used to execute component scripts
+     *      - This also means that we need to pre-fetch all component scripts before executing them
+     */
+    _executeComponentScript(request: RunnerScriptExecutionRequest): RunnerScriptExecutionResult;
+    /** For executing component scripts we need to have synchronous execution function
+    *  Because we don't want to write await $component('name').get() in the code
+    *  This is possible only if we use sync methods in the code
+    *  In this case that's no problem because we need the existing internal instances
+    *      from Component scope for model, metrics, docs, tables
+    *
+    *  NOTE: This is run in the local scope, so 'this' is the execution scope
+    */
+    _executeLocalComponent(request: RunnerScriptExecutionRequest, startRun?: boolean, output?: boolean): RunnerScriptExecutionResult | null;
+    _prefetchComponentScripts(request: string | RunnerScriptExecutionRequest, noCache?: boolean): Promise<Record<string, Script>>;
+    /** Fetch component script from url or local file path */
+    _fetchComponentScript(path?: string): Promise<Script | null>;
+    /** Get component from cache in componentScripts
+     *  Cache needs to be filled by this._prefetchComponentScripts()
+    */
+    getComponentScript(name: string): Script | null;
+    executePipeline(pipeline: Pipeline, request: RunnerScriptExecutionRequest): Promise<RunnerScriptExecutionResult | null>;
+    /** Execute a Pipeline in a isolated scope and extract requested outputs
+     *  NOTE: Based on _executeLocal() but simplified for ease of use
+     */
+    private _executePipelineIsolated;
+    /** Execute from URL of Archiyou library */
+    executeUrl(url: string, params?: Record<string, ScriptParamData>, outputs?: Array<string>): Promise<RunnerScriptExecutionResult>;
+    getDefaultComponentLibraryUrl(): string;
+    getServicesUrl(): string;
+    /** Get a script directly from URL
+     * We need to parse the url to get the library address and that of the script */
+    getScriptFromUrl(url: string): Promise<Script>;
+    _getLibUrlFromScriptUrl(url: string): string | null;
+    _getScriptPathFromScriptUrl(url: string): string | null;
+    _addMetaToResult(scope: RunnerScriptScopeState, request: RunnerScriptExecutionRequest, result: RunnerScriptExecutionResult): RunnerScriptExecutionResult;
+    /** Get results out of local execution scope
+     *  This function is bound to the scope - so 'this' is the execution scope
+     *  If this method is run only if there were no errors during execution
+    */
+    getLocalScopeResults(scope: RunnerScriptScopeState, request: RunnerScriptExecutionRequest): Promise<RunnerScriptExecutionResult>;
+    /** Get results from local execution scope based on
+     *  request.outputs paths
+     *  We gather result by pipeline, because we can have multiple pipelines in the request that need to be run
+     *
+     *  @scope - execution scope to get results from
+     *  @request - execution request with outputs
+     *
+     *  @returns - Array of ScriptOutputData with path and output data { path: ScriptOutputPath, output: any }
+     *
+     *  NOTE: There is a recursive aspect here, because in the default pipeline (main scope) we run pipelines first
+     *      in a seperate scope and get its results. Here this function is used too.
+    */
+    getLocalScopeResultOutputs(scope: RunnerScriptScopeState, request: RunnerScriptExecutionRequest, result: RunnerScriptExecutionResult): Promise<Array<ScriptOutputData>>;
+    /**
+     * Get results out of local execution scope synchronously for Components
+     * For special cases like importing components we want to avoid async methods  */
+    getLocalScopeResultsComponent(scope: any, request: RunnerScriptExecutionRequest): RunnerScriptExecutionResult;
+    /** Export models from given scope, pipeline and using output paths in request.outputs and place in ExecutionResult tree */
+    _exportPipelineModels(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Promise<Array<ScriptOutputData>>;
+    _exportPipelineMetrics(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Promise<Array<ScriptOutputData>>;
+    _exportPipelineTables(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Promise<Array<ScriptOutputData>>;
+    _exportPipelineDocs(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Promise<Array<ScriptOutputData>>;
+    /** Get internal outputs synchronously per pipeline
+     *  Iterate from outputs and run pipelines where needed
+    */
+    getLocalScopeResultOutputsInternal(scope: any, request: RunnerScriptExecutionRequest, result: RunnerScriptExecutionResult): Array<ScriptOutputData>;
+    /** Get internal Obj/Shape model data from local execution scope */
+    _exportPipelineModelsInternal(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Array<ScriptOutputData>;
+    /** Get internal Metric data from local execution scope and set in result tree */
+    _exportPipelineMetricsInternal(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Array<ScriptOutputData>;
+    /** Get internal Table data from local execution scope and set in result tree */
+    _exportPipelineTablesInternal(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Array<ScriptOutputData>;
+    /** Get internal Doc data from local execution scope and set in result tree
+     *  Because of the Doc module is tied to the execution scope, we export raw data here (Doc.toData())
+    */
+    _exportPipelineDocsInternal(scope: any, request: RunnerScriptExecutionRequest, pipeline: string, result: RunnerScriptExecutionResult): Array<ScriptOutputData>;
+    inNode(): boolean;
+    /**
+     * Convert a string value to its native type if possible.
+     * - "true"/"false" (case-insensitive) => boolean
+     * - Numeric strings => number
+     * - Otherwise, return as string
+     */
+    _convertStringValue(value: string): string | number | boolean;
+    /**
+    * Returns the longest substring that is both a suffix of str1 and a prefix of str2.
+    */
+    _stringOverlap(str1: string, str2: string): string;
+}

package/dist/src/RunnerComponentImporter.d.ts

@@ -0,0 +1,71 @@
+import { Runner, Script, RunnerScriptScopeState, Obj, PublishScript, ImportComponentResult } from './internal';
+/**
+ *  Exists in script execution scope
+ *   And gathers all information needed to execute a component script
+ *   and return specific results
+ *
+ *   Executing component script and getting result (async/sync)
+ *      Script execution is async, but we want to avoid using
+ *      "await $component(...).get(...)" which is not user friendly
+ *
+ *      Because all the export functions for raw data (the model Obj/Shapes, table data and doc instances)
+ *      that is by definition always available in the scope
+ *      We can get away with introducing a sync execution method
+ *      RunnerComponentImporter.get() => Runner._executeComponentScript => Runner._executeLocalSync
+ *
+ *  Some usage examples based on get and shortcuts methods model() and all():
+ *
+ *    - leftWall = $component("test/wall", { LENGTH: 300, HEIGHT: 250 }).model() // default pipeline model Obj
+ *    ==> same as: $component("test/wall", { LENGTH: 300, HEIGHT: 250 }).get('default/model')
+ *    - cutShapes = $component("test/box", { WIDTH: 100, DEPTH: 100 }).get('cnc/model')
+ *    - { model: wallShape, docs: wallDocs, tables: wallTables } = $component("test/wall", { }).all()
+ *    ==> same as: $component("test/wall", { }).get('default/model','default/tables', 'default/docs', 'default/metrics')
+ *
+ *
+ */
+export declare class RunnerComponentImporter {
+    DEFAULT_OUTPUTS: string[];
+    _runner: Runner;
+    _scope: RunnerScriptScopeState;
+    name: string;
+    params: Record<string, any>;
+    options: Record<string, any>;
+    script?: PublishScript;
+    _requestedOutputs: Array<string>;
+    constructor(runner: Runner, scope: RunnerScriptScopeState, name: string, params?: Record<string, any>);
+    /**
+     *  Get outputs from component script execution
+     *   This will enable the user to get specific outputs from the component:
+     *      - any pipeline
+     *      - any category: model, docss, tables, metrics
+     *
+     *  @param p - path or array of paths to requested outputs (like 'default/model', 'cnc/model')
+     *
+     *  Components only work with internal data, so we always get 'internal' format
+     *  Some simplications:
+     *      - no other formats than 'internal'
+     *      - we export internal categories like 'model', 'docs', 'tables', 'metrics' directly as module instances
+     *          : no specific entities like 'docs/report'
+     *      - if only one output path given (for example 'default/model') return that directly
+     *
+     *  See RunnerComponentImporter.model() for easy way of getting model
+     *
+     * */
+    get(p: string | Array<string>): ImportComponentResult;
+    /** Shortcut method for getting model */
+    model(): ImportComponentResult;
+    /** Shortcut method for getting everything of default pipeline */
+    all(): ImportComponentResult;
+    /** Really get the script and execute in seperate component scope */
+    _getAndExecute(): ImportComponentResult;
+    /** Execute component script with params and requested outputs
+     *  @param script - PublishScript to execute
+     *  @param params - parameters to pass to the script
+     *  @returns Promise<ImportComponentResult> - result of the execution
+     */
+    _executeComponentScript(script: Script): ImportComponentResult;
+    /** Get component script from Runners cache (in Runner.componentScripts) */
+    _getComponentScript(): Script | null;
+    /** We need to recreate the component object tree into the current scope */
+    _recreateComponentObjTree(tree: Object, parentObj?: Obj): Obj;
+}

package/dist/src/RunnerOps.d.ts

@@ -0,0 +1,15 @@
+/**
+ *  RunnerOps.ts
+ *   Class for some common operations
+ *
+ */
+export declare class RunnerOps {
+    constructor();
+    /**
+     * Saves a Blob, ArrayBuffer, Uint8Array, or string to the local file system.
+     * @param data - The data to save (Blob, ArrayBuffer, Uint8Array, or string).
+     * @param filePath - The path where the file should be saved.
+     * @param overwrite - Whether to overwrite existing files (default: true).
+     */
+    saveBlobToFile(data: Blob | ArrayBuffer | Uint8Array | string, filePath: string, overwrite?: boolean): Promise<void>;
+}

package/dist/src/Script.d.ts

@@ -0,0 +1,78 @@
+import { ScriptParamData, ScriptPublished, ScriptMeta, ScriptParam } from './internal';
+export declare class Script {
+    id: string;
+    name: undefined | string;
+    author: undefined | string;
+    description: undefined | string;
+    tags: string[];
+    created: Date;
+    updated: Date;
+    code: string;
+    params: Record<string, ScriptParam>;
+    presets: Record<string, Record<string, ScriptParamData>>;
+    meta: ScriptMeta | null;
+    published: ScriptPublished | null;
+    previousId?: string;
+    previousVersion?: string;
+    _valid: boolean;
+    constructor(author?: string, name?: string, code?: string, params?: Record<string, ScriptParam>, presets?: Record<string, Record<string, ScriptParamData>>);
+    isValid(): boolean;
+    namespace(): string;
+    validate(): void;
+    _setDefaults(): void;
+    _validateBasics(): boolean;
+    /** Validated ScriptPublished */
+    _validatePublished(): boolean;
+    /** Used by library to set public url of this script */
+    setPublishedUrl(rootUrl: string): this;
+    getDefaultParamValues(): Record<string, any>;
+    /** Check parameter values against script definition params and give back error messages
+     *  @return
+     *      success flag
+     *      Record with valid values only
+     */
+    checkParamValuesVerbose(paramValues: Record<string, any>): {
+        success: boolean;
+        errors: Array<string>;
+        checkedParamValues: Record<string, any>;
+    };
+    /** Simple flag version */
+    checkParamValues(paramValues: Record<string, any>): boolean;
+    validateParamValues(paramValues: Record<string, any>): boolean;
+    /** When a script is executed with a set of params we generate a hash
+     *  to uniquely identify the variant of the script. For example for caching
+     */
+    getVariantId(paramValues: Record<string, any>): Promise<string>;
+    /** Get number of possible variants */
+    getNumVariants(): number;
+    /** Iterate over all possible parameter variants
+     *  @params params Array of parameter names to iterate over, others are kept to default
+     */
+    iterateVariants(only?: Array<string>): Generator<Record<string, any>>;
+    /** Generate all parameter combinations
+     *  This function uses recursion to generate all possible combinations of parameter values.
+    */
+    _generateCombinations(params: Array<ScriptParam>, staticValues: Record<string, any>): Generator<Record<string, any>>;
+    /** Load from raw data
+     *  Some backwards compatibility
+     */
+    fromData(data: Script | ScriptData | Record<string, any>): Script | this;
+    fixSemver(v: string): any;
+    /** To raw data */
+    toData(): ScriptData;
+    /** Export to module string - in this format the Script is saved in the library */
+    toModuleString(): string;
+}
+export interface ScriptData {
+    id: string;
+    name?: string;
+    author?: string;
+    description: string;
+    tags?: string[];
+    created: string | null;
+    updated: string | null;
+    code: string;
+    params: Record<string, ScriptParamData>;
+    presets?: Record<string, Record<string, ScriptParamData>>;
+    published: ScriptPublished | null;
+}

package/dist/src/ScriptOutputManager.d.ts

@@ -0,0 +1,19 @@
+import { ScriptOutputPath, ScriptOutputCategory, RunnerScriptExecutionRequest, RunnerScriptExecutionResult } from './internal';
+export declare class ScriptOutputManager {
+    requestedOutputPaths: Array<ScriptOutputPath>;
+    resolvedOutputsPaths: Array<ScriptOutputPath>;
+    constructor();
+    /** Load incoming request that contains output request paths
+     *  Any warnings will be places inside result.warnings
+     *  @returns number of valid (resolved) output paths generated
+    */
+    loadRequest(request: RunnerScriptExecutionRequest, result?: RunnerScriptExecutionResult, resolve?: boolean): this;
+    /** If we want to manage outputs of a execution result without resolving paths
+     * This also ties outputs to the path objects for easy access
+    */
+    fromResult(result: RunnerScriptExecutionResult): this;
+    getPipelines(): Array<string>;
+    getOutputsByPipeline(pipeline: string): Array<ScriptOutputPath>;
+    getOutputsByPipelineCategory(pipeline: string, category: ScriptOutputCategory): Array<ScriptOutputPath>;
+    getOutputsByPipelineEntityFormats(pipeline: string, category: ScriptOutputCategory, formats: Array<string>): Array<ScriptOutputPath>;
+}

package/dist/src/ScriptOutputPath.d.ts

@@ -0,0 +1,48 @@
+import { ScriptMeta, ScriptOutputCategory, ScriptOutputFormat, ScriptOutputPathData, ScriptOutputDataWrapper } from './internal';
+export declare class ScriptOutputPath {
+    requestedPath: string;
+    resolvedPath: string;
+    valid: boolean;
+    resolved: boolean;
+    pipeline: null | string;
+    category: null | '*' | ScriptOutputCategory;
+    entityName: null | '*' | string;
+    format: null | '*' | ScriptOutputFormat | null;
+    formatOptions: Record<string, any>;
+    _output: any | ScriptOutputDataWrapper;
+    constructor(outputPath?: string);
+    copy(): ScriptOutputPath;
+    toData(): ScriptOutputPathData;
+    fromData(data: ScriptOutputPathData): this;
+    /** Alter path for internal use in context of components
+     *  We try to keep it the same as normal use */
+    internalize(): this;
+    setOutputData(data: any): this;
+    /** Load output path data from a cache file path */
+    fromCacheFilePath(filePath: string): this;
+    /** When saving output to cache we need a file path that contains all the info of the output */
+    toCacheFilePath(what?: 'full' | 'dir' | 'filename'): string | null;
+    private _validate;
+    checkValid(): boolean;
+    /** Resolve any wildcards in request output path by filling in the entity names
+     * @return one or multiple new Script Output instances
+     *          and any warnings
+     * */
+    resolveVerbose(meta: ScriptMeta): {
+        resolved: Array<ScriptOutputPath>;
+        warnings: Array<string>;
+    };
+    /** Simple resolve of wildcards in current output path */
+    resolve(): Array<ScriptOutputPath>;
+    setResolved(): ScriptOutputPath;
+    hasWildCard(): boolean;
+    wildCardsAt(): Array<string>;
+    private _getEntitiesFromMeta;
+    /** Get all available formats by category
+     *  set flag internal to true to also include 'internal' format
+     */
+    private _getFormatsByCategory;
+    private _metaHasEntityName;
+    /** Parse a URL parameter string into an object */
+    private _parseFormatOptions;
+}

package/dist/src/ScriptParam.d.ts

@@ -0,0 +1,78 @@
+import { ModelUnits, ParamType, ParamObjectSchema, ParamBehaviourTarget } from './internal';
+export declare class ScriptParam {
+    MAX_TEXT_LENGTH: number;
+    id: string;
+    type: ParamType;
+    name: string;
+    enabled?: boolean;
+    visible?: boolean;
+    label: string;
+    default?: any;
+    _value?: any | Array<any>;
+    min?: number;
+    max?: number;
+    step?: number;
+    options?: Array<string>;
+    length?: number;
+    listElem?: ScriptParam;
+    schema?: ParamObjectSchema;
+    order?: number;
+    iterable?: boolean;
+    description?: string;
+    units?: ModelUnits;
+    _definedProgrammatically?: boolean;
+    _behaviours?: Record<ParamBehaviourTarget, (curParam: ScriptParamData, params: Record<string, ScriptParam>) => any> | {};
+    constructor();
+    fromData(param: ScriptParamData): this;
+    /** Export ScriptParam instance to equivalent data structure */
+    toData(): ScriptParamData;
+    /** Validate incoming ScriptParamData object */
+    validateInput(param: ScriptParamData): ScriptParamData;
+    /** Make a easy class method */
+    static validate(param: ScriptParamData): ScriptParamData;
+    /** Validate structure of ParamData by type
+     *  NOTE: _value is always internal, so we don't validate it here
+     *  use validateParamValue() for value validation
+    */
+    validateStructure(param: ScriptParamData): boolean;
+    validateValue(v: any): boolean;
+    /** Validate any value against current Param instance */
+    validateValueVerbose(v: any): {
+        success: boolean;
+        errors: Array<string>;
+    };
+    /** If it makes sense to iterate over param values
+     *  This means there are a limited set of values
+    */
+    isIterable(): boolean;
+    /** Get number of values that a Paramater can take
+     *  If a Param is not iterable we directly return 1
+    */
+    numValues(): number;
+    /** Iterate over all param values */
+    iterateValues(): Generator<any>;
+}
+/** Data version of ScriptParam instance */
+export interface ScriptParamData {
+    id?: string;
+    type: ParamType;
+    name: string;
+    enabled?: boolean;
+    visible?: boolean;
+    label: string;
+    _value?: any | Array<any>;
+    default?: any;
+    min?: number;
+    max?: number;
+    step?: number;
+    listElem?: ScriptParamData;
+    schema?: ParamObjectSchema;
+    options?: Array<string>;
+    length?: number;
+    units?: ModelUnits;
+    order?: number;
+    iterable?: boolean;
+    description?: string;
+    _definedProgrammatically?: boolean;
+    _behaviours?: Record<string, string>;
+}

package/dist/src/Selector.d.ts

@@ -0,0 +1,48 @@
+import { Selection, Shape, ShapeCollection } from './internal';
+/**
+
+    Class for selecting parts of Shapes
+    
+    ex:
+        Shape.select('E|Z') - Edges parallel to Z axis
+        Shape.select('V<<Z') - Vertex with smallest Z coordinate
+        Shape.select('V<X=10') - Vertex with X coordinate smaller than 10
+
+        subselect:
+        
+        Shape.select('F||top).select('V||front')
+
+        add selections:
+
+        Shape.select('F||top and F||front')
+
+    How to add new selectors:
+    
+    There is a configuration based scaffolding to easy parse the selectors.
+    Parsing selection strings is done in these phases:
+
+    1. What are we looking for and how many: scan for target Shape (_setSelectionTargetShape)
+        ex: F == Faces = return all Faces, Face = return first Face -
+
+    2.  Which selector and parameters: _executeSelectString
+        _executeSelectString contains all parsing logic and is the place where you add new selectors.
+        !!!! IMPORTANT !!!! Parsing order of selector regular expressions is important:
+        Place the more complex ones first and simple ones (that might overlap with complex ones) later.
+
+    3. Parsed selector and parameters are forwarded to specific selector method on Shape class as defined in _executeSelectString
+        that returns the real Shapes or ShapeCollection based on number of results a selector is suppose to return
+
+*/
+export declare class Selector {
+    parentShape: Shape | ShapeCollection;
+    selectString: string;
+    lastSelection: Selection;
+    constructor(shape?: Shape);
+    /** Select Sub Shapes of a Shape by using a selection expression */
+    select(s: string): ShapeCollection;
+    /** We allow multiple selections with keyword 'and' */
+    _splitSelectStrings(selectString: string): Array<string>;
+    /** Scans string of selection for what we are looking for ~ the targetShape */
+    _setSelectionTargetShape(selection: Selection): Selection;
+    _executeSelectString(selectString: string): ShapeCollection;
+}

package/dist/src/Services.d.ts

@@ -0,0 +1,68 @@
+/**
+ *
+ *  API Wrapper for Archiyou services
+ *
+ *  - conversion between different data formats
+ *  - TODO: more
+ */
+/** API wrapper for Archiyou services */
+export declare class Services {
+    private _baseUrl;
+    private _timeout;
+    private _headers;
+    private _nodeFormDataModule;
+    private _nodeFormFetchModule;
+    constructor(baseUrl: string, timeout?: number);
+    /** Set authentication token */
+    setAuthToken(token: string): this;
+    /** Set custom headers */
+    setHeaders(headers: Record<string, string>): this;
+    /** If Services instance is set with baseUrl */
+    ifSet(): boolean;
+    /** Check if the API service is up and running */
+    isUp(): Promise<boolean>;
+    getConversionFormats(): Promise<Array<ServiceConvertFormat>>;
+    /** Convert data from one format to another */
+    convert(data: ArrayBuffer | string, fromExt: string, toExt: string): Promise<ServiceConvertResponse>;
+    isNode(): boolean;
+    /** Upload binary data for conversion - works in both Node.js and browser */
+    private _uploadAndConvert;
+    private _loadNodeModules;
+    /** Node.js multipart upload */
+    private _uploadAndConvertNode;
+    /** Browser multipart upload */
+    private _uploadAndConvertBrowser;
+    /** Get available conversion formats */
+    getSupportedFormats(): Promise<{
+        input: string[];
+        output: string[];
+    }>;
+    /** Make HTTP request with error handling */
+    private _request;
+}
+export interface ServiceConvertFormat {
+    name: string;
+    ext: string;
+    description?: string;
+    importable: boolean;
+    exportable: boolean;
+    tool: 'assimp' | 'gdal';
+}
+export interface ServiceConvertRequest {
+    data: ArrayBuffer | string;
+    fromFormat: string;
+    toFormat: string;
+}
+export interface ServiceConvertResponse {
+    success: boolean;
+    data?: ArrayBuffer;
+    error?: string;
+    metadata?: {
+        originalSize: number;
+        convertedSize: number;
+        processingTime: number;
+    };
+}
+export interface ServiceHealthResponse {
+    message: string;
+}