@jpmorganchase/mosaic-types 0.1.0-beta.10

package/dist/IFileAccess.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { Options, Pattern, Entry } from 'fast-glob';
+import type { DirectoryJSON, IRealpathOptions, IMkdirOptions, IReaddirOptions, IStatOptions, TData, TMode, TDataOut, Dirent, Stats, TStatNumber } from 'memfs';
+import type { PathLike, symlink } from 'fs';
+import type { Page } from './Page.js';
+/**
+ * This is the core underlying filesystem, which directly interfaces with a memfs Volume to mutate the filesystem
+ */
+export interface IFileAccess {
+    glob(pattern: Pattern, options?: Omit<Options, 'absolute' | 'fs'>): Promise<string[] | Entry[]>;
+    mkdir(dir: PathLike, options?: TMode | IMkdirOptions): Promise<void>;
+    readdir(dir: PathLike, options?: string | IReaddirOptions): Promise<TDataOut[] | Dirent[]>;
+    readFile(file: PathLike): Promise<TDataOut>;
+    realpath(target: string, options?: string | IRealpathOptions): Promise<TDataOut>;
+    stat(file: PathLike, options?: IStatOptions): Promise<Stats<TStatNumber>>;
+    unlink(target: PathLike): Promise<void>;
+    symlink(target: PathLike, alias: PathLike, type?: symlink.Type): Promise<void>;
+    writeFile(file: PathLike, data: TData): Promise<void>;
+    toJSON(): DirectoryJSON;
+    fromJSON(json: DirectoryJSON): void;
+    exists(file: PathLike): Promise<boolean>;
+    $$reset(): void;
+    $$freeze(): void;
+    readonly $$frozen: boolean;
+    $$unfreeze(): void;
+    $$clearCache(): void;
+    $$symlinksFromJSON(page: {
+        [key: string]: {
+            target: string;
+            type: string;
+        }[];
+    }): Promise<void>;
+    symlinksToJSON(): {
+        [key: string]: {
+            target: string;
+            type: string;
+        }[];
+    };
+    $$addReadFileHook(hook: (result: Page, filepath: PathLike) => Promise<Page>): void;
+}

package/dist/Meta.d.ts

@@ -0,0 +1,5 @@
+export declare type Meta<AdditionalProps> = {
+    title?: string;
+    route: string;
+    lastModified: Date;
+} & Record<string, unknown> & AdditionalProps;

package/dist/Mode.d.ts

@@ -0,0 +1 @@
+export declare type MosaicMode = 'active' | 'static';

package/dist/MutableData.d.ts

@@ -0,0 +1,74 @@
+export interface Aliases {
+    [key: string]: Set<string>;
+}
+export interface FSRef {
+    $$path?: string | string[];
+    $$value?: string;
+}
+export interface GlobalRefs {
+    [key: string]: FSRef;
+}
+export interface ScopedRefs {
+    [key: string]: FSRef;
+}
+export interface BaseData {
+    refs?: ScopedRefs | [];
+    globalRefs?: GlobalRefs | [];
+    aliases?: Aliases | [];
+}
+export declare type MutableData<T = {}> = ImmutableData<T> & {
+    /**
+     * Set arbitrary data onto the config object. This value will persist across plugins and
+     * also be sent to the parent process when it executes plugins there as well.
+     * Values can be retrieved from `data`.
+     * This data is one-way, it can only be set/mutated in the child process lifecycle stages
+     * This will be reset everytime the relevant source receives new pages
+     * @param data Data to MERGE into the existing blob
+     */
+    setData(data: Partial<T>, overwrite?: boolean): void;
+    /**
+     * Helper function for declaring new aliases that will be applied by the AliasPlugin.
+     * Values can be retrieved from `data.aliases`
+     * This will be reset everytime the relevant source receives new pages
+     * @param fullPath The file/fullPath the alias will point to
+     * @param aliases Array of aliases to use when pointing to this page
+     */
+    setAliases(targetPath: string, aliases: string[]): void;
+    /**
+     * Helper function for declaring new tags (which are basically aliases to /.tags) that will be applied by the AliasPlugin.
+     * Values can be retrieved from `data.aliases`
+     * This will be reset everytime the relevant source receives new pages
+     * @param fullPath The file/fullPath the alias will point to
+     * @param tags Array of tag names to use when pointing to this page
+     */
+    setTags(targetPath: string, tags: string[]): void;
+    /**
+     * Helper function for declaring new refs that will be applied by the RefPlugin
+     * This will be reset everytime the relevant source receives new pages
+     * Values can be retrieved from `data.refs`
+     * @param targetPath The file/fullPath to write the ref to
+     * @param targetPropPath The path to the property where the ref will be applied
+     * @param refValue The value of the ref (can be a wildcard)
+     */
+    setRef(targetFilepath: string, targetPropPath: string | string[], refValue: string): void;
+    /**
+     * Same as `setRef`, but do not pre-resolve this ref - wait until the file is read and use the global filesystem for it
+     * @param targetPath The file/fullPath to write the ref to
+     * @param targetPropPath The path to the property where the ref will be applied
+     * @param refValue The value of the ref (can be a wildcard)
+     */
+    setGlobalRef(targetFilepath: string, targetPropPath: string | string[], refValue: string): void;
+    /**
+     * This object, but without the mutation methods like `setAliases`, `setData` etc
+     */
+    asReadOnly(): ImmutableData<T>;
+};
+export declare type ImmutableData<T = {}> = {
+    readonly data: Readonly<T & {
+        readonly refs: string[];
+        readonly aliases: Set<{
+            $$path: string[];
+            $$value: string;
+        }>;
+    }>;
+};

package/dist/Page.d.ts

@@ -0,0 +1,20 @@
+/**
+ * `Page` is a type, which at a minimum has a `fullPath`, but can also contain metadata and `content`
+ */
+export declare type Page = {
+    fullPath: string;
+    title?: string;
+    /**
+     * Friendly fullPaths are the shortest possible paths that will point to a page.
+     * They are useful for creating more user-friendly links on pages, rather than using a full filesystem path.
+     * They originally start as the same as `fullPath`, but can be modified by plugins whenever they make a change to how a page resolves.
+     * e.g. The `PagesWithoutFileExtPlugin` modifies the friendly fullPath after it creates aliases for every page (to allow
+     * them to be referenced without a file extension). Another example would be a plugin that allows `/index` to be
+     * automatically added if a fullPath points to a directory -- the `route` could then be modified by that
+     * plugin to remove `/index`
+     */
+    route?: string;
+    lastModified?: Date;
+    type?: string;
+    content?: string;
+};

package/dist/Plugin.d.ts

@@ -0,0 +1,113 @@
+import type { IUnionVolume, IVolumeImmutable, IVolumeMutable, IVolumePartiallyMutable } from './Volume.js';
+import type { PluginModuleDefinition } from './index.js';
+import type { Serialiser } from './Serialiser.js';
+import type { Page } from './Page.js';
+import type { MutableData, ImmutableData } from './MutableData.js';
+export declare type LoadedPlugin = Partial<Plugin<Page>> & PluginModuleDefinition;
+export declare type LifecycleMethod = keyof Plugin<Page>;
+/**
+ * Plugins are lifecycle-based hooks that are called on every source at different stages.
+ * Consumers will never need to invoke a lifecycle method; but for technical clarity - when a lifecycle method is called,
+ * it will trigger `pluginRunner` which executes it on every source automatically.
+ */
+export declare type Plugin<TPage extends Page = Page, TOptions = Record<string, unknown>, ConfigData = Record<string, unknown>, GlobalConfigData = ConfigData> = {
+    /**
+     * Plugin lifecycle method that triggers inside child processes.
+     * The first lifecycle hook to trigger after receiving pages from a source. The pages can safely be mutated and will be reflected in the final
+     * filesystem that gets generated.
+     * @param pages Array of pages from the source
+     * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
+     * @param param.config A mutable object for sharing data with other lifecycle phases of all plugins for this source (including in the main thread) in this plugin
+     * @param options The options passed in when declaring the plugin
+     * @returns {Promise<Page[]>} Must re-return an array of `Page` objects, modified or not
+     */
+    $afterSource?: (pages: TPage[], helpers: {
+        serialiser: Serialiser<TPage>;
+        config: MutableData<ConfigData>;
+        pageExtensions: string[];
+        ignorePages: string[];
+    }, options?: TOptions) => Promise<Array<TPage>>;
+    /**
+     * Plugin lifecycle method that triggers inside child processes.
+     * Calls after a filesystem has been built up from the source pages.
+     * @param mutableFilesystem Mutable virtual filesystem instance with all of this source's pages inside (and symlinks applied)
+     * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
+     * @param param.config A mutable object for sharing data with other lifecycle phases of all plugins for this source (including in the main thread) in this plugin
+     * @param options The options passed in when declaring the plugin
+     * @returns {void} No return expected
+     */
+    $beforeSend?: (mutableFilesystem: IVolumePartiallyMutable, helpers: {
+        serialiser: Serialiser<TPage>;
+        pageExtensions: string[];
+        ignorePages: string[];
+        config: MutableData<ConfigData>;
+    }, options?: TOptions) => Promise<void>;
+    /**
+     * Plugin lifecycle method that triggers inside the main process.
+     * Calls after the filesystem and symlinks have been reconstructed due to a change to the current source. This happens in the main thread.
+     * Pages will NOT be cached when read at this stage, to allow for reading content and writing a new copy of it without the cached version taking effect.
+     * This method is safe to use with lazy loading, as the filesystem should return the full page when read.
+     * NOTE: Plugin methods that trigger inside the parent process should be async and highly optimised to avoid holding up the main thread.
+     * You should also be mindful of race conditions when reading / writing to the global filesystem from this method - as other plugins may
+     * also have a read copy of the same file and it could end up out of sync.
+     * @param mutableFilesystem Mutable filesystem instance with all of this source's pages inside (and symlinks re-applied)
+     * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
+     * @param param.config An immutable object for reading data from other lifecycle phases of all plugins for this source in the child process for this plugin. Shared only with this source.
+     * @param param.globalConfig An immutable object for reading data from other lifecycle phases of all plugins. Shared across all sources.
+     * @param param.sharedFilesystem Mutable filesystem instance independent of any sources. Useful for global pages, like sitemaps
+     * @param param.globalFilesystem Immutable union filesystem instance with all source's pages (and symlinks applied)
+     * @param options The options passed in when declaring the plugin
+     * @returns {void} No return expected
+     */
+    afterUpdate?: (mutableFilesystem: IVolumePartiallyMutable, helpers: {
+        serialiser: Serialiser<TPage>;
+        config: ImmutableData<ConfigData>;
+        globalFilesystem: IUnionVolume;
+        sharedFilesystem: IVolumeMutable;
+        globalConfig: ImmutableData<GlobalConfigData>;
+        pageExtensions: string[];
+        ignorePages: string[];
+    }, options?: TOptions) => Promise<void>;
+    /**
+     * Plugin lifecycle method that triggers inside the main process everytime ANY source emits new pages.
+     * This method should return a boolean that will indicate if this source should clear page caches.
+     * This method calls whenever another source (not this one) has changed.
+     * Returning `undefined`, false or no value, will result in the cache to be retained
+     * @param updatedSourceFilesystem Immutable filesystem for the source that changed
+     * @param param.config An immutable object for reading data from other lifecycle phases of all plugins for this source in the child process for this plugin
+     * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
+     * @param param.globalFilesystem Immutable union filesystem instance with all source's pages (and symlinks applied)
+     * @param options The options passed in when declaring the plugin
+     * @returns {Promise<boolean>} A boolean indicating whether to clear the cache for this source
+     */
+    shouldClearCache?: (updatedSourceFilesystem: IVolumeImmutable, helpers: {
+        serialiser: Serialiser<TPage>;
+        config: ImmutableData<ConfigData>;
+        globalFilesystem: IUnionVolume;
+        pageExtensions: string[];
+        ignorePages: string[];
+    }, options?: TOptions) => Promise<boolean>;
+    /**
+     * Plugin lifecycle method that triggers inside the main process whenever a request to save content is made.
+     * This method should return the result of the save
+     * Returning `undefined`, false or no value, will result in the plugin runner discarding the result.
+     * @param path the route of the content being edited.
+     * @param data the data from the the request
+     * @param sourceOptions options used to create the source that is running the plugin
+     * @param mutableFilesystem Mutable filesystem instance with all of this source's pages inside (and symlinks re-applied)
+     * @param param.serialiser A matching `Serialiser` for serialising/deserialising pages when reading/writing to the filesystem
+     * @param param.config An immutable object for reading data from other lifecycle phases of all plugins for this source in the child process for this plugin. Shared only with this source.
+     * @param param.sharedFilesystem Mutable filesystem instance independent of any sources. Useful for global pages, like sitemaps
+     * @param param.namespace The namespace of the source running the plugin
+     * @param options The options passed in when declaring the plugin
+     * @returns {Promise<unknown>} The result of the save
+     */
+    saveContent?(path: string, data: unknown, sourceOptions: unknown, helpers: {
+        serialiser: Serialiser<TPage>;
+        config: ImmutableData<ConfigData>;
+        sharedFilesystem: IVolumeMutable;
+        pageExtensions: string[];
+        ignorePages: string[];
+        namespace: string;
+    }, options?: TOptions): Promise<unknown>;
+};

package/dist/Serialiser.d.ts

@@ -0,0 +1,26 @@
+import type { TDataOut } from 'memfs';
+import type { SerialiserModuleDefinition } from './index.js';
+import type { Page } from './Page.js';
+/**
+ * Serialisers are a form of plugin that tells Mosaic how to turn a file from/to a storable form for the filesystem
+ * or a `Page` object.
+ * For technical clarity - when a parser method is called, it will trigger `parserRunner` which checks the `fullPath` against
+ * the `test` option that was passed in the Mosaic config file, to find a suitable parser.
+ */
+export declare type Serialiser<TPage extends Page = Page> = {
+    /**
+     * Method to turn a raw page (e.g. an MDX file) into a `Page` object
+     * @param fullPath Route on virtual disk (should be full fullPath, not an alias)
+     * @param page Page in string or buffer form (i.e. an MDX page with frontmatter or a JSON file as a string)
+     * @returns Page object in the `Page` format
+     */
+    deserialise: (fullPath: string, page: TDataOut) => Promise<TPage>;
+    /**
+     * Method to load a raw page from disk (e.g. an MDX file) and return into a `Page` object
+     * @param fullPath Route on virtual disk (should be full fullPath, not an alias)
+     * @param page Page in `Page` form
+     * @returns Page content
+     */
+    serialise: (fullPath: string, page: TPage) => Promise<TDataOut>;
+};
+export declare type LoadedSerialiser = Serialiser & SerialiserModuleDefinition;

package/dist/Session.d.ts

@@ -0,0 +1,39 @@
+export declare type JWT = {
+    exp: number;
+    UserID?: string;
+    JPMCIdentifier?: string;
+    UID?: string;
+    EmployeeCorporateID?: string;
+    CostCenter?: string;
+    Country?: string;
+    CountryCode?: string;
+    Department?: string;
+    DisplayName?: string;
+    Email?: string;
+    EmployeeType?: string;
+    FirstName?: string;
+    LastName?: string;
+    LOB?: string;
+    LocationCode?: string;
+};
+export declare type Session = {
+    isLoggedIn: boolean;
+    accessToken?: string;
+    isCypressSession?: boolean;
+    expires?: number;
+    user?: {
+        avatarUrl: string;
+        sid: string;
+        country?: string;
+        countryCode?: string;
+        costCenter?: string;
+        department?: string;
+        displayName?: string;
+        email?: string;
+        employeeType?: string;
+        firstName?: string;
+        lastName?: string;
+        lob?: string;
+        locationCode?: string;
+    };
+};

package/dist/Source.d.ts

@@ -0,0 +1,9 @@
+import type { Observable } from 'rxjs';
+import type { Serialiser } from './Serialiser.js';
+import type { Page } from './Page.js';
+export declare type Source<Options = {}> = {
+    create(options: Options, { serialiser, pageExtensions }: {
+        pageExtensions: string[];
+        serialiser: Serialiser;
+    }): Observable<Page[]>;
+};

package/dist/SourceWorkflow.d.ts

@@ -0,0 +1,6 @@
+export declare type SourceWorkflowAction<TSourceOptions, TOptions> = (sourceOptions: TSourceOptions, workflowOptions: TOptions, ...args: any[]) => Promise<unknown>;
+export declare type SourceWorkflow<TSourceOptions = unknown, TOptions = unknown> = {
+    name: string;
+    options?: TOptions;
+    action: SourceWorkflowAction<TSourceOptions, TOptions>;
+};

package/dist/Volume.d.ts

@@ -0,0 +1,125 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { DirectoryJSON, IRealpathOptions, IMkdirOptions, IReaddirOptions, IStatOptions, TData, TMode, TDataOut, Dirent, Stats, TStatNumber } from 'memfs';
+import type { PathLike, symlink } from 'fs';
+import type { Options, Pattern, Entry } from 'fast-glob';
+/**
+ * Volumes are lightweight decorators which wrap `FileAccess` and limit access to the underlying API for different use-cases
+ * Examples include disallowing mutation or allowing underlying functions like resetting
+ */
+export interface IVolume {
+    namespace: string;
+    reset?(): void;
+    toJSON(): DirectoryJSON;
+    symlinksToJSON(): {
+        [key: string]: {
+            target: string;
+            type: string;
+        }[];
+    };
+    fromJSON?(json: DirectoryJSON): void;
+    promises: {
+        exists(file: PathLike): Promise<boolean>;
+        glob(pattern: Pattern, options?: Options): Promise<string[] | Entry[]>;
+        mkdir(dir: PathLike, options?: TMode | IMkdirOptions): Promise<void>;
+        readdir(dir: PathLike, options?: string | IReaddirOptions): Promise<TDataOut[] | Dirent[]>;
+        readFile(file: PathLike): Promise<TDataOut>;
+        realpath(target: string, options?: string | IRealpathOptions): Promise<TDataOut>;
+        stat(file: PathLike, options?: IStatOptions): Promise<Stats<TStatNumber>>;
+        symlink(target: PathLike, alias: PathLike, type?: symlink.Type): Promise<void>;
+        unlink(target: PathLike): Promise<void>;
+        writeFile(file: PathLike, data: TData): Promise<void>;
+    };
+}
+export interface IVolumePartiallyMutable extends Omit<IVolume, 'reset' | 'fromJSON'> {
+    /**
+     * Functions that will be called after a page is read from the filesystem for the first time (since last cache clear).
+     * The value returned from this hook will *replace* the contents of the read file.
+     * @param hook Any function that invokes an `afterRead` plugin
+     * @returns Promise<Page>
+     */
+    __internal_do_not_use_addReadFileHook(hook: (filepath: PathLike, fileData: TDataOut) => Promise<TDataOut>): void;
+}
+export interface IUnionVolume extends Omit<IVolumeImmutable, 'promises'> {
+    promises: Pick<IVolumeImmutable, 'promises'> & {
+        /**
+         * Reads a file
+         * @param file Path
+         * @returns Promise<TDataOut>
+         */
+        readFile(file: PathLike): Promise<TDataOut>;
+        readFile(file: PathLike, options?: {
+            includeConflicts?: false;
+        }): Promise<TDataOut>;
+        /**
+         * Reads 1 or more files (if multiple files exist at the same location within the union filesystem)
+         * @param file Path
+         * @param options.includeConflicts If multiple files exist at the same location in the filesystem, return them all as an array
+         * @returns Promise<TDataOut[]>
+         */
+        readFile(file: PathLike, options: {
+            includeConflicts: true;
+        }): Promise<TDataOut[]>;
+    };
+    /**
+     * Scopes a filesystem to specific namespaces
+     * @param {string[]} namespaces Array of namespaces to limit this filesystem to
+     * @returns A new immutable union filesystem
+     */
+    scope(namespaces: string[]): IUnionVolume;
+}
+export interface IVolumeMutable extends IVolume {
+    /**
+     * Functions that will be called after a page is read from the filesystem for the first time (since last cache clear).
+     * The value returned from this hook will *replace* the contents of the read file.
+     * @param hook Any function that invokes an `afterRead` plugin
+     * @returns Promise<Page>
+     */
+    __internal_do_not_use_addReadFileHook(hook: (filepath: PathLike, fileData: TDataOut) => Promise<TDataOut>): void;
+    /**
+     * Restricted filesystems can be written to, but cannot be frozen, updated or reset
+     */
+    asRestricted(): IVolumePartiallyMutable;
+    /**
+     * ReadOnly filesystems cannot be mutated in any way, including freezing, updating or reseting
+     */
+    asReadOnly(): IVolumeImmutable;
+    /**
+     * Clears the filesystem's internal page cache - used when the cache may be outdated due to a source emiting new data or a dependency changing.
+     */
+    clearCache(): void;
+    /**
+     * Re-enables mutations on the underlying `FileAccess`.
+     */
+    unfreeze(): void;
+    /**
+     * Freezes an object, preventing all mutations on the underlying `FileAccess` object
+     * Freezing a filesystem indicates that the mutation period has ended and the file system can no longer be modified.
+     * When a filesystem is unfrozen, it is considered to be in flux, so may change as more plugins are called.
+     * When a filesystem is frozen, it is considered to be stable and ready to begin serving finalised versions of files.
+     */
+    freeze(): void;
+    /**
+     * Is this filesystem frozen/mutable?
+     * @returns {boolean}
+     */
+    readonly frozen: boolean;
+    /**
+     * Appends content to the filesystem
+     * @param json A JSON blob in the form of {[fullPath]: "{fullPath: '', content: ''}"}
+     */
+    fromJSON(json: DirectoryJSON): void;
+    symlinksFromJSON(json: {
+        [key: string]: {
+            target: string;
+            type: string;
+        }[];
+    }): Promise<void>;
+    /**
+     * Completely resets the filesystem.
+     * This includes clearing page cache, erasing filesystem data, clearing symlinks etc
+     */
+    reset(): void;
+}
+export interface IVolumeImmutable extends Omit<IVolumePartiallyMutable, 'fromJSON' | 'reset' | 'promises' | '__internal_do_not_use_addReadFileHook'> {
+    promises: Omit<IVolume['promises'], 'writeFile' | 'symlink' | 'mkdir' | 'unlink' | 'rmdir' | 'rm' | 'rename'>;
+}

package/dist/WorkerData.d.ts

@@ -0,0 +1,13 @@
+import type { SerialiserModuleDefinition, PluginModuleDefinition, SourceModuleDefinition } from './index.js';
+export declare type WorkerData<Options = {}> = {
+    options: Options & Pick<PluginModuleDefinition, 'options'> & Pick<SourceModuleDefinition, 'options'> & {
+        pageExtensions: string[];
+    };
+    name: string;
+    namespace: string;
+    pageExtensions: string[];
+    ignorePages: string[];
+    plugins: PluginModuleDefinition[];
+    serialisers: SerialiserModuleDefinition[];
+    modulePath: string;
+};

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+import type { SerialiserModuleDefinition, MosaicConfig, PluginModuleDefinition, SourceModuleDefinition, SourceWorkflow } from '@jpmorganchase/mosaic-schemas';
+export * from './IFileAccess.js';
+export * from './Meta.js';
+export * from './MutableData.js';
+export * from './Page.js';
+export * from './Plugin.js';
+export * from './Serialiser.js';
+export * from './Source.js';
+export * from './Volume.js';
+export * from './WorkerData.js';
+export * from './Mode.js';
+export * from './Session.js';
+export { SerialiserModuleDefinition, MosaicConfig, PluginModuleDefinition, SourceModuleDefinition, SourceWorkflow };

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@jpmorganchase/mosaic-types",
+  "version": "0.1.0-beta.10",
+  "description": "Mosaic BitBucket source for core file system",
+  "license": "Apache-2.0",
+  "author": "",
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "engines": {
+    "node": ">= 16.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:jpmorganchase/mosaic.git"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -fr dist",
+    "lint": "eslint --ignore-pattern \"**/__tests__/**\""
+  },
+  "devDependencies": {
+    "@jpmorganchase/mosaic-schemas": "^0.1.0-beta.10",
+    "memfs": "^3.4.12",
+    "rxjs": "^7.5.5",
+    "zod": "^3.19.1"
+  }
+}