@supernova-studio/pulsar-core 2.0.14 → 2.0.17

package/build/main/core/src/pulsar/PulsarInterface.d.ts

@@ -0,0 +1,117 @@
+import { DSMBridgeConfiguration, PLHighlightEngineToken } from '@supernova-studio/pulsar-language';
+import { PLAutocompleteEngineSuggestion, PLAutocompleteEngineApplicationResult } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStore } from '..';
+import { PCExporterSourceContextType } from '../model/sources/ExporterSource';
+import { PCLogger } from '../tools/Logger';
+import { PCExporter, PCExporterEngine, PCExporterEnvironment } from './../model/exporters/Exporter';
+/** Exporter detail containing data about the currently loaded exporter */
+export declare class PCEngineExporterDetail {
+    id: string;
+    name: string;
+    description: string;
+    author?: string;
+    organization?: string;
+    homepage: string;
+    source_dir: string;
+    version: string;
+    routingVersion?: string;
+    icon?: string;
+    readme?: string;
+    usesBrands: boolean;
+    usesThemes: boolean;
+    repository?: {
+        url: string;
+        branch: string;
+        directory: string;
+    };
+    config?: {
+        sources?: string;
+        output?: string;
+        js?: string;
+    };
+    engine: PCExporterEngine;
+    executable?: string;
+    tags: Array<string>;
+}
+/** Source detail containing data about specific source including its code definition */
+export declare class PCEngineSourceDetail {
+    id: string;
+    path: string;
+    targetsFullExport: boolean;
+    targetsSandbox: boolean;
+    context: PCExporterSourceContextType;
+    content: string;
+}
+/** Unique, computed file group */
+export declare class PCEngineFileGroup {
+    name: string;
+    path: string;
+    files: Array<PCEngineFileDescriptor>;
+    groups: Array<PCEngineFileGroup>;
+    constructor(name: string, path: string, files: Array<PCEngineFileDescriptor>, groups: Array<PCEngineFileGroup>);
+}
+/** Result of a specific run of a singular exporter. Also used to retrieve export in progress as a way to load files gradually as they are fed and written by the exporter */
+export declare type PCEngineExporterProcessingResult = {
+    exporterId: string;
+    runId: string;
+    state: PCEngineExporterState;
+    emittedFiles: Array<PCEngineFileDescriptor>;
+    rootGroup: PCEngineFileGroup;
+    logger: PCLogger;
+    emittedFileChecksums: Object;
+};
+/** Result of a specific run of a singular source. Can optionally produce multiple files if emitter was used within the source */
+export declare type PCEngineSourceProcessingResult = {
+    sourceId: string;
+    logger: PCLogger;
+    producedContent: Array<PCEngineFileDescriptor>;
+};
+/** File descriptor for one specific file produced by either source, map generation or exporter run */
+export declare type PCEngineFileDescriptor = {
+    name: string;
+    path: string;
+    content: string;
+    source: 'primary' | 'emitter';
+    type: 'string' | 'copy_file' | 'copy_file_remote';
+    hash?: string;
+};
+export declare enum PCEngineExporterState {
+    running = "running",
+    finished_success = "finished_success",
+    finished_failure = "finished_failure"
+}
+export interface PCPulsarInterface {
+    /** Initiates Pulsar library from existing exporter. This is only for internal use (especially for tests) and doesn't validate integrity of the exporter, and shouldn't not be used in production! */
+    initiateWithExporter(exporter: PCExporter, environment: PCExporterEnvironment): Promise<PCEngineExporterDetail>;
+    /** Initiates Pulsar library from a local folder. This must point to directly-readable directory, can't be zip. */
+    initiateWithLocalFolderURL(url: string, environment: PCExporterEnvironment): Promise<PCEngineExporterDetail>;
+    /** Initiates Pulsar library from github URL. Can only be used when filesystem is present (CI, VSCode) */
+    initiateWithGitHubPackageURL(githubURL: string, accessToken: string | undefined, environment: PCExporterEnvironment): Promise<PCEngineExporterDetail>;
+    /** Initiates Pulsar library from remote package URL. Can only be used when filesystem is present (CI, VSCode) */
+    initiateWithRemotePackageURL(s3URL: string, environment: PCExporterEnvironment): Promise<PCEngineExporterDetail>;
+    /** Initiates Pulsar library from package URL. Can only be used if filesystem is NOT present (Browser) and ignores some capabilities, such as copying assets */
+    initiateWithRemoteBrowserPackageURL(packageURL: string, environment: PCExporterEnvironment): Promise<PCEngineExporterDetail>;
+    /** Retrieve underlaying exporter object. Not to be used on the client, as it exposes other properties of exporter that are not to be consumed */
+    getExporterBackingObject(): PCExporter;
+    /** Retrieve details about currently loaded exporter. Note that this only retrieves settings of the exporter, to request Sources and mapping, use separate functions */
+    getExporterDetail(): PCEngineExporterDetail;
+    /** Get all Sources associated with loaded exporter. Note that Sources don't contain their code definitions, as those need to be requested separaterly */
+    getSources(): Array<PCEngineSourceDetail>;
+    /** Get specific source associated with loaded exporter */
+    getSourceById(sourceId: string): PCEngineSourceDetail;
+    setUserConfiguration(data: Object): any;
+    /** Get reference store containing description of all elements in the DSM, including all context categories */
+    getDSMContextStore(dsmBridgeConfig: DSMBridgeConfiguration): Promise<DSMReferenceStore>;
+    /** Execute source code and retrieve the resulting code. This also retrieves any emitted extra files. Throws error when source is not found */
+    executeSourceById(sourceId: string, dsmBridgeConfig: DSMBridgeConfiguration, contextKey: string, contextId: string): Promise<PCEngineSourceProcessingResult>;
+    /** @deprecated Use PCPulsarStaticAnalysis instead. Suggest next characters, words or snippets to be inserted into pulsar code as user types */
+    suggestNextFromSourceCode(code: string, selectionLocation: number, selectionLength: number): Array<PLAutocompleteEngineSuggestion>;
+    /** @deprecated Use PCPulsarStaticAnalysis instead.  Apply autocompletion result to specified pulsar code */
+    applyAutocompletionResultToCode(code: string, selectionLocation: number, selectionLength: number, apply: PLAutocompleteEngineSuggestion): PLAutocompleteEngineApplicationResult;
+    /** @deprecated Use PCPulsarStaticAnalysis instead.  Compute highlight tokens for the provided pulsar code */
+    suggestHighlightFromSourceCode(code: string): Array<PLHighlightEngineToken>;
+    /** Execute entire exporter and retrieve all files produced as a result of this export */
+    executeExporter(dsmBridgeConfig: DSMBridgeConfiguration, debugMode: boolean): Promise<PCEngineExporterProcessingResult>;
+    /** Retrieve intermediate output of exporter in progress */
+    retrieveRunningExporterState(): PCEngineExporterProcessingResult | null;
+}

package/build/main/core/src/pulsar/PulsarStaticAnalysis.d.ts

@@ -0,0 +1,14 @@
+import { DSMExecutionContext, PLHighlightEngineToken, PLError, PLAutocompleteEngineSuggestion, PLAutocompleteEngineApplicationResult } from '@supernova-studio/pulsar-language';
+import { PCPulsarStaticAnalysisInterface } from './PulsarStaticAnalysisInterface';
+export declare class PCPulsarStaticAnalysis implements PCPulsarStaticAnalysisInterface {
+    private codeManager;
+    constructor();
+    /** Run analysis and return errors if found, otherwise empty */
+    analyzeBlueprintCode(code: string, sourceFileName: string, executionContext?: DSMExecutionContext | undefined): Array<PLError>;
+    /** Suggest next characters, words or snippets to be inserted into pulsar code as user types */
+    suggestNextFromBlueprintCode(code: string, selectionLocation: number, selectionLength: number): Array<PLAutocompleteEngineSuggestion>;
+    /** Apply autocompletion result to specified pulsar code */
+    applyAutocompletionResultToCode(code: string, selectionLocation: number, selectionLength: number, apply: PLAutocompleteEngineSuggestion): PLAutocompleteEngineApplicationResult;
+    /** Compute highlight tokens for the provided pulsar code */
+    suggestHighlightFromBlueprintCode(code: string): Array<PLHighlightEngineToken>;
+}

package/build/main/core/src/pulsar/PulsarStaticAnalysisInterface.d.ts

@@ -0,0 +1,12 @@
+import { PLHighlightEngineToken } from '@supernova-studio/pulsar-language';
+import { PLAutocompleteEngineApplicationResult, PLAutocompleteEngineSuggestion, PLError } from '@supernova-studio/pulsar-language';
+export interface PCPulsarStaticAnalysisInterface {
+    /** Run analysis and return errors if found, otherwise empty */
+    analyzeBlueprintCode(code: string, sourceFileName: string): Array<PLError>;
+    /** Suggest next characters, words or snippets to be inserted into pulsar code as user types */
+    suggestNextFromBlueprintCode(code: string, selectionLocation: number, selectionLength: number): Array<PLAutocompleteEngineSuggestion>;
+    /** Apply autocompletion result to specified pulsar code */
+    applyAutocompletionResultToCode(code: string, selectionLocation: number, selectionLength: number, apply: PLAutocompleteEngineSuggestion): PLAutocompleteEngineApplicationResult;
+    /** Compute highlight tokens for the provided pulsar code */
+    suggestHighlightFromBlueprintCode(code: string): Array<PLHighlightEngineToken>;
+}

package/build/main/core/src/pulsar/managers/PulsarBlueprintManager.d.ts

@@ -0,0 +1,16 @@
+import { PCExporter } from './../../model/exporters/Exporter';
+import { PCExporterSource } from '../../model/sources/ExporterSource';
+export declare class PCPulsarSourceManager {
+    private exporter;
+    constructor(exporter: PCExporter);
+    /** Get all sources associated with loaded exporter. Note that sources don't contain their code definitions, as those need to be requested separaterly */
+    getSources(): Array<PCExporterSource>;
+    /** Get specific source associated with loaded exporter */
+    getSourceById(sourceId: string): PCExporterSource;
+    /** Create new source for loaded exporter. Source comes with default name and code and uses generic context */
+    createNewSource(): PCExporterSource;
+    /** Delete specified source. Throws error when source is not found */
+    deleteSourceById(sourceId: string): void;
+    /** Update source id. Id must be non-empty and contain at least 3 characters. It must also be unique in scope. Note that this also updates all maps that are referencing this source */
+    updateSourceLocation(oldSourceId: string, newSourceId: string, newPath: string): PCExporterSource;
+}

package/build/main/core/src/pulsar/managers/PulsarCIManager.d.ts

@@ -0,0 +1,31 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import { PCLogger } from '@pulsar/core/tools/Logger';
+import { DSMBridgeConfiguration } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStore } from '../..';
+import { PCPulsarExporterMode } from '../Pulsar';
+import { PCEngineExporterProcessingResult } from '../PulsarInterface';
+export declare class PCPulsarCIManager {
+    private exporter;
+    private mode;
+    private currentExporterInstance;
+    constructor(exporter: PCExporter, mode: PCPulsarExporterMode);
+    /** Execute entire exporter and retrieve all files produced as a result of this export */
+    executeExporter(dsmBridgeConfig: DSMBridgeConfiguration, debugMode: boolean, logger?: PCLogger): Promise<PCEngineExporterProcessingResult>;
+    /** Execute exporter under new engine */
+    executeExporterNew(dsmBridgeConfig: DSMBridgeConfiguration, debugMode: boolean, logger?: PCLogger): Promise<PCEngineExporterProcessingResult>;
+    /** Execute exporter under legacy engine */
+    executeExporterLegacy(dsmBridgeConfig: DSMBridgeConfiguration, debugMode: boolean, logger?: PCLogger): Promise<PCEngineExporterProcessingResult>;
+    /** Retrieve intermediate output of exporter in progress */
+    retrieveRunningExporterState(): PCEngineExporterProcessingResult | null;
+    /** Get reference store containing description of all elements in the DSM, including all context categories */
+    getDSMContextStore(dsmBridgeConfig: DSMBridgeConfiguration): Promise<DSMReferenceStore>;
+    private convertExportResultToPulsarResult;
+    private convertExportResultToPulsarResultWithChecksums;
+    private compileChecksums;
+    private parseName;
+    fetchReferenceStore(dsmBridgeConfig: DSMBridgeConfiguration): Promise<DSMReferenceStore>;
+    static fetchReferenceStoreStatic(dsmBridgeConfig: DSMBridgeConfiguration): Promise<DSMReferenceStore>;
+    fetchReferenceStoreForSandboxedComponent(componentId: string): Promise<DSMReferenceStore>;
+    private computeRootFileGroupFromFiles;
+    private pathPermutations;
+}

package/build/main/core/src/pulsar/managers/PulsarCodeManager.d.ts

@@ -0,0 +1,24 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import { PCLogger } from '@pulsar/core/tools/Logger';
+import { DSMBridgeConfiguration, DSMExecutionContext, PLBlueprint, PLHighlightEngineToken, PLAutocompleteEngineApplicationResult, PLAutocompleteEngineSuggestion } from '@supernova-studio/pulsar-language';
+import { PCEngineSourceProcessingResult } from './../PulsarInterface';
+export declare class PCPulsarCodeManager {
+    private exporter;
+    private codeExecutionContext;
+    constructor(exporter: PCExporter);
+    /** Execute source code and retrieve the resulting output. This also retrieves any emitted extra files. Throws error when source is not found */
+    executeSourceById(sourceId: string, dsmBridgeConfig: DSMBridgeConfiguration, contextKey: string, contextId: string, logger?: PCLogger): Promise<PCEngineSourceProcessingResult>;
+    /** Update source code definition. Content can be anything */
+    updateSourceCodeDefinitionForSourceId(sourceId: string, definition: string): void;
+    /** Update source code definition. Overview can be empty. Throws error when source is not found */
+    updateSourceLocation(oldSourceId: string, newSourceId: string, newPath: string): void;
+    /** Suggest next characters, words or snippets to be inserted into pulsar code as user types */
+    suggestNextFromSourceCode(code: string, selectionLocation: number, selectionLength: number): Array<PLAutocompleteEngineSuggestion>;
+    /** Apply autocompletion result to specified pulsar code */
+    applyAutocompletionResultToCode(code: string, selectionLocation: number, selectionLength: number, apply: PLAutocompleteEngineSuggestion): PLAutocompleteEngineApplicationResult;
+    /** Compute highlight tokens for the provided pulsar code */
+    suggestHighlightFromSourceCode(code: string): Array<PLHighlightEngineToken>;
+    createContextData(contextKey: string, contextId: string): Map<string, any>;
+    parseSource(declaration: string, name: string, executionContext: DSMExecutionContext): Promise<PLBlueprint>;
+    interpretSource(source: PLBlueprint, data: Map<string, any>, executionContext: DSMExecutionContext): Promise<string>;
+}

package/build/main/core/src/pulsar/managers/PulsarConfigurationManager.d.ts

@@ -0,0 +1,6 @@
+import { PCExporter } from '../../model/exporters/Exporter';
+export declare class PCPulsarConfigurationManager {
+    private exporter;
+    constructor(exporter: PCExporter);
+    setUserConfiguration(data: Object): void;
+}

package/build/main/core/src/pulsar/managers/PulsarExporterManager.d.ts

@@ -0,0 +1,7 @@
+import { PCExporter } from './../../model/exporters/Exporter';
+export declare class PCPulsarExporterManager {
+    private exporter;
+    constructor(exporter: PCExporter);
+    /** Retrieve details about currently loaded exporter. Note that this only retrieves settings of the exporter, to request blueprints and mapping, use separate functions */
+    getExporterDetail(): PCExporter;
+}

package/build/main/core/src/pulsar/managers/generators/PulsarExporterPackageAnalyzer.d.ts

@@ -0,0 +1,10 @@
+import { PCPulsar } from '../../Pulsar';
+export declare class PCPulsarExporterPackageAnalyzer {
+    pulsar: PCPulsar;
+    constructor(pulsar: PCPulsar);
+    packageFilePaths(): Array<string>;
+    private configurationFilePaths;
+    private resourceFilePaths;
+    private sourceFilePaths;
+    private auxiliaryFilePaths;
+}

package/build/main/core/src/pulsar/managers/generators/PulsarExporterPackageGenerator.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { PCEngineExporterProcessingResult } from '../../PulsarInterface';
+import { PCPulsar } from '../../Pulsar';
+export declare class PCPulsarExporterPackageGenerator {
+    static createZipBufferForTemporaryExporter(pulsar: PCPulsar): NodeJS.ReadableStream;
+    static constructZIPBufferForExporterResult(result: PCEngineExporterProcessingResult): Promise<NodeJS.ReadableStream>;
+}

package/build/main/core/src/pulsar/managers/generators/PulsarFiles.d.ts

@@ -0,0 +1,21 @@
+export declare type PCPulsarFileMap = Map<string, PCPulsarFile>;
+export declare type PCPulsarFile = {
+    directory: string;
+    filename: string;
+    name: string;
+    extension: string;
+    content: string;
+    key: string;
+};
+export declare type PCPulsarFileDescriptor = {
+    /** Absolute file path that always points to the file and can be used with fs. to read the file */
+    absoluteFSPath: string;
+    /** Relative file path where the root is the package root */
+    relativePackagePath: string;
+    /** File name, without extension */
+    name: string;
+    /** File extension, without name */
+    extension: string;
+    /** File and extension, without path */
+    fullName: string;
+};

package/build/main/core/src/pulsar/managers/loaders/PulsarExporterPackageBrowserLoader.d.ts

@@ -0,0 +1,12 @@
+import { PCExporter, PCExporterEnvironment } from '@pulsar/core/model/exporters/Exporter';
+import { PCPulsarExporterPackageLoader } from './PulsarExporterPackageLoader';
+export declare class PCPulsarExporterPackageBrowserLoader extends PCPulsarExporterPackageLoader {
+    remoteSourceUrl: string;
+    environment: PCExporterEnvironment;
+    constructor(remoteSourceUrl: string, environment: PCExporterEnvironment);
+    initialize(): Promise<{
+        exporter: PCExporter;
+        fsUrl: string | null;
+    }>;
+    private downloadZIPFromURL;
+}

package/build/main/core/src/pulsar/managers/loaders/PulsarExporterPackageFileSystemLoader.d.ts

@@ -0,0 +1,15 @@
+import { PCExporter, PCExporterEnvironment } from '@pulsar/core/model/exporters/Exporter';
+import { PCPulsarExporterPackageLoader } from './PulsarExporterPackageLoader';
+export declare class PCPulsarExporterPackageFileSystemLoader extends PCPulsarExporterPackageLoader {
+    rootDirectoryUrl: string;
+    configurationFileName: string;
+    environment: PCExporterEnvironment;
+    constructor(rootDirectoryUrl: string, environment: PCExporterEnvironment);
+    initialize(): Promise<{
+        exporter: PCExporter;
+        fsUrl: string | null;
+    }>;
+    private validateAndLoadLegacyExporter;
+    private validateAndLoadLatestExporter;
+    private getExporterBaseObject;
+}

package/build/main/core/src/pulsar/managers/loaders/PulsarExporterPackageGithubLoader.d.ts

@@ -0,0 +1,32 @@
+import type { SimpleGithubParseResult } from '@supernova-studio/simple-parse-github-url';
+import JSZip from 'jszip';
+import { PCExporter, PCExporterEnvironment } from '@pulsar/core/model/exporters/Exporter';
+import { PCPulsarExporterPackageLoader } from './PulsarExporterPackageLoader';
+import { Octokit } from 'octokit';
+declare type ExporterRepository = {
+    octokit: Octokit;
+    branch: string;
+    directory: string;
+    segments: SimpleGithubParseResult;
+};
+export declare class PCPulsarExporterPackageGithHubLoader extends PCPulsarExporterPackageLoader {
+    repositoryURL: string;
+    accessToken: string;
+    environment: PCExporterEnvironment;
+    constructor(githubURL: string, accessToken: string, environment: PCExporterEnvironment);
+    initialize(): Promise<{
+        exporter: PCExporter;
+        fsUrl: string | null;
+    }>;
+    private fetchPaged;
+    private hasMore;
+    listBranches(octokit: Octokit, owner: string, repo: string): Promise<string[]>;
+    initGitRepository(): Promise<ExporterRepository>;
+    retrieveExporterArchive(): Promise<{
+        zip: JSZip;
+        repositoryUrl: string;
+        dropRootDirectory: boolean;
+    } & ExporterRepository>;
+    private downloadZIPFromURL;
+}
+export {};

package/build/main/core/src/pulsar/managers/loaders/PulsarExporterPackageLoader.d.ts

@@ -0,0 +1,10 @@
+import { PCExporter } from '../../../model/exporters/Exporter';
+export declare class PCPulsarExporterPackageLoader {
+    constructor();
+    initialize(): Promise<{
+        exporter: PCExporter;
+        fsUrl: string | null;
+    }>;
+    /** Make sure path doesn't start with / */
+    normalizeFSPath(path: string): string;
+}

package/build/main/core/src/pulsar/managers/loaders/PulsarExporterPackageMemoryLoader.d.ts

@@ -0,0 +1,14 @@
+import { PCExporter, PCExporterEnvironment } from '@pulsar/core/model/exporters/Exporter';
+import { PCPulsarExporterPackageLoader } from './PulsarExporterPackageLoader';
+import JSZip from 'jszip';
+export declare class PCPulsarExporterPackageMemoryLoader extends PCPulsarExporterPackageLoader {
+    exporterPackage: Map<string, JSZip.JSZipObject>;
+    configurationFileName: string;
+    environment: PCExporterEnvironment;
+    constructor(exporterPackage: JSZip, environment: PCExporterEnvironment);
+    initialize(): Promise<{
+        exporter: PCExporter;
+        fsUrl: string | null;
+    }>;
+    private getExporterBaseObject;
+}

package/build/main/core/src/pulsar/managers/loaders/PulsarExporterPackageURLLoader.d.ts

@@ -0,0 +1,12 @@
+import { PCExporter, PCExporterEnvironment } from '@pulsar/core/model/exporters/Exporter';
+import { PCPulsarExporterPackageLoader } from './PulsarExporterPackageLoader';
+export declare class PCPulsarExporterPackageURLLoader extends PCPulsarExporterPackageLoader {
+    remoteSourceUrl: string;
+    environment: PCExporterEnvironment;
+    constructor(remoteSourceUrl: string, environment: PCExporterEnvironment);
+    initialize(): Promise<{
+        exporter: PCExporter;
+        fsUrl: string | null;
+    }>;
+    private downloadZIPFromURL;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterAssetLoader.d.ts

@@ -0,0 +1,13 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import { PCBundledResource } from '@pulsar/core/model/assets/ExporterBundledResource';
+export declare class PCPulsarExporterBundledResourceLoader {
+    exporter: PCExporter;
+    iconName: string;
+    constructor(exporter: PCExporter);
+    loadResourcesFromPackageDirectory(packageLocalFSPath: string): Promise<Array<PCBundledResource>>;
+    loadIconFromPackageDirectory(packageLocalFSPath: string): Promise<PCBundledResource | null>;
+    loadBlockIconsFromPackageDirectory(packageLocalFSPath: string): Promise<void>;
+    loadVariantIconsFromPackageDirectory(packageLocalFSPath: string): Promise<void>;
+    getListOfAssetFilesFromRoot(directory: string): Promise<Array<string>>;
+    fileExists(file: any): Promise<boolean>;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterConfigLoader.d.ts

@@ -0,0 +1,9 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import JSZip from 'jszip';
+export declare class PCPulsarExporterConfigLoader {
+    exporter: PCExporter;
+    configName: string;
+    constructor(exporter: PCExporter);
+    loadConfigFromExporterPackage(exporterPackage: Map<string, JSZip.JSZipObject>): Promise<boolean>;
+    loadConfigFromPackageDirectory(packageLocalFSPath: string): boolean;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterJSLoader.d.ts

@@ -0,0 +1,9 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import JSZip from 'jszip';
+export declare class PCPulsarExporterJSLoader {
+    exporter: PCExporter;
+    constructor(exporter: PCExporter);
+    loadJSHelperFromExporterPackage(exporterPackage: Map<string, JSZip.JSZipObject>): Promise<boolean>;
+    loadJSHelperFromPackageDirectory(packageLocalFSPath: string): boolean;
+    loadJSExecutableFromPackageDirectory(packageLocalFSPath: string): boolean;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterLocalConfigLoader.d.ts

@@ -0,0 +1,9 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import JSZip from 'jszip';
+export declare class PCPulsarExporterLocalConfigLoader {
+    exporter: PCExporter;
+    configName: string;
+    constructor(exporter: PCExporter);
+    loadLocalConfigFromExporterPackage(exporterPackage: Map<string, JSZip.JSZipObject>): Promise<boolean>;
+    loadLocalConfigFromPackageDirectory(packageLocalFSPath: string): boolean;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterMappingLoader.d.ts

@@ -0,0 +1,21 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import { PCExporterMapBlueprint } from '@pulsar/core/model/maps/ExporterMapBlueprint';
+import { PCExporterMapBundledResource } from '@pulsar/core/model/maps/ExporterMapBundledResource';
+import JSZip from 'jszip';
+import { PCExporterMapAsset } from '@pulsar/core/model/maps/ExporterMapAsset';
+export declare type PCPulsarExporterMappingLoaderPack = {
+    blueprintMaps?: Array<PCExporterMapBlueprint>;
+    bundledResourceMaps?: Array<PCExporterMapBundledResource>;
+    assetMaps?: Array<PCExporterMapAsset>;
+};
+export declare class PCPulsarExporterMappingLoader {
+    exporter: PCExporter;
+    defaultName: string;
+    constructor(exporter: PCExporter);
+    loadPulsarMappingFromExporterPackage(exporterPackage: Map<string, JSZip.JSZipObject>): Promise<PCPulsarExporterMappingLoaderPack>;
+    loadPulsarMappingFromPackageDirectory(packageLocalFSPath: string): PCPulsarExporterMappingLoaderPack;
+    private createMapping;
+    private processBlueprintMapping;
+    private processBundledResourceMapping;
+    private processAssetGenerationMapping;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterObjectLoader.d.ts

@@ -0,0 +1,6 @@
+import { PCExporter, PCExporterEnvironment } from '@pulsar/core/model/exporters/Exporter';
+export declare class PCPulsarExporterObjectLoader {
+    environment: PCExporterEnvironment;
+    constructor(environment: PCExporterEnvironment);
+    initializeConfigurationFromDefinition(definition: string): Promise<PCExporter>;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterReadmeLoader.d.ts

@@ -0,0 +1,9 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import JSZip from 'jszip';
+export declare class PCPulsarExporterReadmeLoader {
+    exporter: PCExporter;
+    readmeName: string;
+    constructor(exporter: PCExporter);
+    loadReadmeFromExporterPackage(exporterPackage: Map<string, JSZip.JSZipObject>): Promise<boolean>;
+    loadReadmeFromPackageDirectory(packageLocalFSPath: string): boolean;
+}

package/build/main/core/src/pulsar/managers/loaders/partials/PulsarExporterSourceLoader.d.ts

@@ -0,0 +1,14 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import { PCExporterSource } from '@pulsar/core/model/sources/ExporterSource';
+import JSZip from 'jszip';
+export declare class PCPulsarExporterSourceLoader {
+    exporter: PCExporter;
+    extension: string;
+    defaultName: string;
+    constructor(exporter: PCExporter);
+    loadPulsarSourcesFromExporterPackage(exporterPackage: Map<string, JSZip.JSZipObject>): Promise<Array<PCExporterSource>>;
+    enhanceSourcesWithPackageConfiguration(exporterPackage: Map<string, JSZip.JSZipObject>): Promise<void>;
+    loadPulsarSourcesFromPackageDirectory(packageLocalFSPath: string): Promise<Array<PCExporterSource>>;
+    enhanceSourcesWithConfiguration(packageLocalFSPath: string): void;
+    getListOfSourceFilesFromRoot(directory: string): Promise<Array<string>>;
+}

package/build/main/core/src/pulsar/managers/loaders/support/PulsarExporterUnzipper.d.ts

@@ -0,0 +1,11 @@
+import JSZip from 'jszip';
+import { DirectoryResult } from 'tmp-promise';
+export declare class PCPulsarExporterUnzipper {
+    zip: JSZip;
+    constructor(zip: JSZip);
+    unarchiveToTemporaryUrl(dropRootDirectory: boolean): Promise<DirectoryResult>;
+    /** Parse out directory from full file path. Only works with file paths, but that is the only thing this will ever get */
+    private writeDirectoryFromPath;
+    /** Ensure directory exists - if it doesn't create it, recursively */
+    private ensureDirectoryExistence;
+}

package/build/main/core/src/pulsar/managers/loaders/support/PulsarPathParser.d.ts

@@ -0,0 +1,4 @@
+import { PCPulsarFileDescriptor } from '../../generators/PulsarFiles';
+export declare class PCPulsarPathParser {
+    static parsePath(filepath: string, rootPackagePath: string): PCPulsarFileDescriptor;
+}

package/build/main/core/src/pulsar/managers/loaders/validators/PulsarExporterConfigurationValidator.d.ts

@@ -0,0 +1,11 @@
+import { PCExporterConfigurationProperty, PCExporterConfigurationPropertyArray, PCExporterConfigurationPropertyBoolean, PCExporterConfigurationPropertyEnum, PCExporterConfigurationPropertyNumber, PCExporterConfigurationPropertyObject, PCExporterConfigurationPropertyString } from '../../../../model/exporters/configuration/ExporterConfigurationProperty';
+export declare class PCPulsarExporterConfigurationValidator {
+    static validateLocalConfigAgainstDefinition(localContent: string, configDefinition: Array<PCExporterConfigurationProperty>): object;
+    static validateExporterConfigFileContent(content: string): Array<PCExporterConfigurationProperty>;
+    static validateEnumProperty(property: PCExporterConfigurationPropertyEnum, index: number): void;
+    static validateBooleanProperty(property: PCExporterConfigurationPropertyBoolean, index: number): void;
+    static validateStringProperty(property: PCExporterConfigurationPropertyString, index: number): void;
+    static validateNumberProperty(property: PCExporterConfigurationPropertyNumber, index: number): void;
+    static validateArrayProperty(property: PCExporterConfigurationPropertyArray, index: number): void;
+    static validateObjectProperty(property: PCExporterConfigurationPropertyObject, index: number): void;
+}

package/build/main/core/src/pulsar/managers/loaders/validators/PulsarExporterMappingValidator.d.ts

@@ -0,0 +1,8 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+export declare class PCPulsarExporterMappingValidator {
+    validateOutputConfigFileContent(content: string, exporter: PCExporter): Object;
+    private validateBlueprintConfiguration;
+    private validateBundledResourceConfiguration;
+    private validateAssetConfiguration;
+    private isDirectory;
+}

package/build/main/core/src/pulsar/managers/loaders/validators/PulsarExporterObjectValidator.d.ts

@@ -0,0 +1,10 @@
+import { PCExporterModel } from '@pulsar/core/model/exporters/Exporter';
+import { PCExporterContributionModel } from '@pulsar/core/model/exporters/ExporterContribution';
+export declare class PCPulsarExporterObjectValidator {
+    static validateExporterConfigFileContent(content: string): PCExporterModel;
+    static validateExporterConfigFileNewEngine(content: string): PCExporterModel;
+    static validateExporterContribution(parsedConfiguration: PCExporterModel): void;
+    static validateExporterContributionConfigurationProperties(parsedConfiguration: PCExporterContributionModel): void;
+    static validateExporterContributionBlocks(parsedConfiguration: PCExporterContributionModel): void;
+    static validateExporterContributionBlockVariants(parsedConfiguration: PCExporterContributionModel): void;
+}

package/build/main/core/src/pulsar/managers/loaders/validators/PulsarExporterSourceValidator.d.ts

@@ -0,0 +1,4 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+export declare class PCPulsarExporterSourceValidator {
+    static validateSourceConfigFileContent(content: string, exporter: PCExporter): Object;
+}

package/build/main/core/src/pulsar/managers/loaders/validators/PulsarJSONValidator.d.ts

@@ -0,0 +1,3 @@
+export declare class PCPulsarJSONValidator {
+    static validateParseJSONContent(content: string): Object;
+}

package/build/main/core/src/tests/TestConfiguration.d.ts

@@ -0,0 +1,10 @@
+export declare class UnitTestConfiguration {
+    dsmEmail: string;
+    dsmPass: string;
+    designSystemVersionId: string;
+    designSystemId: string;
+    brandId: string;
+    apiUrl: string;
+    apiVersion: string;
+    accessToken: string;
+}

package/build/main/core/src/tests/casebuilders/ci.d.ts

@@ -0,0 +1,12 @@
+import { PCExporter } from './../../model/exporters/Exporter';
+import { PCExportConfiguration } from './../../engine/configuration/ExportConfiguration';
+import { PCPulsarCIManager } from '../../pulsar/managers/PulsarCIManager';
+import { PCPulsarExporterMode } from '../../pulsar/Pulsar';
+export declare type ExportPack = {
+    exporter: PCExporter;
+    manager: PCPulsarCIManager;
+    configuration: PCExportConfiguration;
+    accessToken: string;
+};
+export declare function executeExportPack(pack: ExportPack): Promise<import("../..").PCEngineExporterProcessingResult>;
+export declare function newExportTestPack(mode: PCPulsarExporterMode): Promise<ExportPack>;

package/build/main/core/src/tests/casebuilders/configuration.d.ts

@@ -0,0 +1,5 @@
+import { PCExporter } from './../../model/exporters/Exporter';
+import { DSMReferenceStore } from './../../model/dsm/DSMReferenceStore';
+import { PCExportConfiguration } from './../../engine/configuration/ExportConfiguration';
+import { PCPulsarExporterMode } from '../../pulsar/Pulsar';
+export declare function newDevExportConfiguration(exporter: PCExporter, store: DSMReferenceStore, exportMode?: PCPulsarExporterMode): Promise<PCExportConfiguration>;

package/build/main/core/src/tests/casebuilders/dsm.d.ts

@@ -0,0 +1,7 @@
+import { PCExporter } from '@pulsar/core/model/exporters/Exporter';
+import { DSMBridge, DSMExecutionContext } from '@supernova-studio/pulsar-language';
+import { DSMReferenceStore } from '../..';
+export declare function newConfiguredDSMExecutionContext(exporter: PCExporter): Promise<DSMExecutionContext>;
+export declare function newConfiguredDSMStore(): Promise<DSMReferenceStore>;
+export declare function newConfiguredDSMBridge(): Promise<DSMBridge>;
+export declare function newConfiguredDSMToken(): Promise<string>;

package/build/main/core/src/tests/casebuilders/modelObjects.d.ts

@@ -0,0 +1,14 @@
+import { PCExporter } from './../../model/exporters/Exporter';
+import { PCExporterSource, PCExporterSourceContextType } from '../../model/sources/ExporterSource';
+import { PCExporterMapBlueprint } from '../../model/maps/ExporterMapBlueprint';
+import { PCExporterContributionConfigurationItemModel } from '@pulsar/core/model/exporters/ExporterContributionConfigurationItem';
+export declare function newEmptyExporter(): PCExporter;
+export declare function newFullExporter(configuration?: Array<PCExporterContributionConfigurationItemModel>): PCExporter;
+export declare function newBlueprintFor(exporter: PCExporter, definition: string, name: string, path: string | null, context: PCExporterSourceContextType, targetsFullExport?: boolean, targetsSandbox?: boolean): PCExporterSource;
+export declare function newGenericBlueprintFor(exporter: PCExporter, id: string, definition: string): PCExporterSource;
+export declare function newComponentBlueprintFor(exporter: PCExporter, id: string, definition: string): PCExporterSource;
+export declare function newComponentGroupBlueprintFor(exporter: PCExporter, id: string, definition: string): PCExporterSource;
+export declare function newTokenGroupBlueprintFor(exporter: PCExporter, id: string, definition: string): PCExporterSource;
+export declare function newTokenTypeBlueprintFor(exporter: PCExporter, id: string, definition: string): PCExporterSource;
+export declare function newThemeBlueprintFor(exporter: PCExporter, id: string, definition: string): PCExporterSource;
+export declare function newOutputInvokingBlueprint(blueprint: string, writeTo: string | null, writeUsing: string | null, exporter: PCExporter): PCExporterMapBlueprint;

package/build/main/core/src/tests/complex/TestExporter.spec.d.ts

@@ -0,0 +1 @@
+export {};