@inizioevoke/veeva-astroclm-core 1.0.0

package/dist/env/schema.d.ts

@@ -0,0 +1,15 @@
+import { envField } from 'astro/config';
+type BooleanField = ReturnType<typeof envField.boolean>;
+type EnumField = ReturnType<typeof envField.enum>;
+export type EnvFieldName = 'BUILD_TARGET' | 'WEB_ENV' | 'WEB_SCALING' | 'VEEVA_TRAINING' | 'VEEVA_ENV' | 'VEEVA_PLATFORM' | 'LOG_LEVEL' | 'LOG_TIME' | 'LOG_OUTPUT';
+export declare const BUILD_TARGET: EnumField;
+export declare const WEB_ENV: EnumField;
+export declare const WEB_SCALING: BooleanField;
+export declare const VEEVA_TRAINING: BooleanField;
+export declare const VEEVA_ENV: EnumField;
+export declare const VEEVA_PLATFORM: EnumField;
+export declare const LOG_LEVEL: EnumField;
+export declare const LOG_TIME: EnumField;
+export declare const LOG_OUTPUT: EnumField;
+declare const schema: Record<EnvFieldName, BooleanField | EnumField>;
+export default schema;

package/dist/env/schema.js

@@ -0,0 +1,28 @@
+import { envField } from 'astro/config';
+import { BUILD_TARGETS, WEB_ENVS, VEEVA_ENVS, VEEVA_PLATFORMS, LOG_LEVELS, LOG_TIMES, LOG_OUTPUTS, DEFAULT_BUILD_TARGET, DEFAULT_WEB_ENV, DEFAULT_VEEVA_ENV, DEFAULT_VEEVA_PLATFORM, DEFAULT_LOG_LEVEL, DEFAULT_LOG_TIME, DEFAULT_LOG_OUTPUT, } from '../lib/const.js';
+const envPublicOptional = {
+    context: 'client',
+    access: 'public',
+    optional: true
+};
+export const BUILD_TARGET = envField.enum({ ...envPublicOptional, values: BUILD_TARGETS, default: DEFAULT_BUILD_TARGET });
+export const WEB_ENV = envField.enum({ ...envPublicOptional, values: WEB_ENVS, default: DEFAULT_WEB_ENV });
+export const WEB_SCALING = envField.boolean({ ...envPublicOptional, default: false });
+export const VEEVA_TRAINING = envField.boolean({ ...envPublicOptional, default: false });
+export const VEEVA_ENV = envField.enum({ ...envPublicOptional, values: VEEVA_ENVS, default: DEFAULT_VEEVA_ENV });
+export const VEEVA_PLATFORM = envField.enum({ ...envPublicOptional, values: VEEVA_PLATFORMS, default: DEFAULT_VEEVA_PLATFORM });
+export const LOG_LEVEL = envField.enum({ ...envPublicOptional, values: LOG_LEVELS, default: DEFAULT_LOG_LEVEL });
+export const LOG_TIME = envField.enum({ ...envPublicOptional, values: LOG_TIMES, default: DEFAULT_LOG_TIME });
+export const LOG_OUTPUT = envField.enum({ ...envPublicOptional, values: LOG_OUTPUTS, default: DEFAULT_LOG_OUTPUT });
+const schema = {
+    BUILD_TARGET,
+    WEB_ENV,
+    WEB_SCALING,
+    VEEVA_TRAINING,
+    VEEVA_ENV,
+    VEEVA_PLATFORM,
+    LOG_LEVEL,
+    LOG_TIME,
+    LOG_OUTPUT
+};
+export default schema;

package/dist/lib/const.d.ts

@@ -0,0 +1,15 @@
+import type { BuildTarget, WebEnv, VeevaEnv, VeevaPlatform, LogLevel, LogTime, LogOutput } from '../types';
+export declare const BUILD_TARGETS: BuildTarget[];
+export declare const WEB_ENVS: WebEnv[];
+export declare const VEEVA_ENVS: VeevaEnv[];
+export declare const VEEVA_PLATFORMS: VeevaPlatform[];
+export declare const LOG_LEVELS: LogLevel[];
+export declare const LOG_TIMES: LogTime[];
+export declare const LOG_OUTPUTS: LogOutput[];
+export declare const DEFAULT_BUILD_TARGET: BuildTarget;
+export declare const DEFAULT_WEB_ENV: WebEnv;
+export declare const DEFAULT_VEEVA_ENV: VeevaEnv;
+export declare const DEFAULT_VEEVA_PLATFORM: VeevaPlatform;
+export declare const DEFAULT_LOG_LEVEL: LogLevel;
+export declare const DEFAULT_LOG_TIME: LogTime;
+export declare const DEFAULT_LOG_OUTPUT: LogOutput;

package/dist/lib/const.js

@@ -0,0 +1,14 @@
+export const BUILD_TARGETS = ['veeva', 'web'];
+export const WEB_ENVS = ['development', 'production'];
+export const VEEVA_ENVS = ['client', 'evoke'];
+export const VEEVA_PLATFORMS = ['salesforce', 'vault'];
+export const LOG_LEVELS = ['disabled', 'error', 'debug'];
+export const LOG_TIMES = ['none', 'date', 'time', 'datetime', 'performance'];
+export const LOG_OUTPUTS = ['console', 'screen'];
+export const DEFAULT_BUILD_TARGET = 'web';
+export const DEFAULT_WEB_ENV = 'development';
+export const DEFAULT_VEEVA_ENV = 'client';
+export const DEFAULT_VEEVA_PLATFORM = 'salesforce';
+export const DEFAULT_LOG_LEVEL = 'disabled';
+export const DEFAULT_LOG_TIME = 'time';
+export const DEFAULT_LOG_OUTPUT = 'console';

package/dist/lib/env.d.ts

@@ -0,0 +1,8 @@
+import type { BuildTarget, VeevaEnv, VeevaPlatform } from '../types';
+export interface Env {
+    BUILD_TARGET: BuildTarget;
+    VEEVA_ENV: VeevaEnv;
+    VEEVA_PLATFORM: VeevaPlatform;
+    VEEVA_TRAINING: boolean;
+}
+export default function loadEnv(mode?: string): Promise<Env>;

package/dist/lib/env.js

@@ -0,0 +1,17 @@
+import * as Constants from './const.js';
+import parseEnv from "./parse-env.js";
+export default async function loadEnv(mode) {
+    const env = await parseEnv({
+        BUILD_TARGET: Constants.BUILD_TARGETS,
+        VEEVA_ENV: Constants.VEEVA_ENVS,
+        VEEVA_PLATFORM: Constants.VEEVA_PLATFORMS,
+        VEEVA_TRAINING: 'boolean'
+    }, {
+        mode
+    });
+    env.BUILD_TARGET = env.BUILD_TARGET ?? Constants.DEFAULT_BUILD_TARGET,
+        env.VEEVA_ENV = env.VEEVA_ENV ?? Constants.DEFAULT_VEEVA_ENV,
+        env.VEEVA_PLATFORM = env.VEEVA_PLATFORM ?? Constants.DEFAULT_VEEVA_PLATFORM,
+        env.VEEVA_TRAINING = env.VEEVA_TRAINING ?? false;
+    return env;
+}

package/dist/lib/index.d.ts

@@ -0,0 +1,5 @@
+export * from './const.js';
+export { default as loadEnv } from './env.js';
+export { default as parseArgv } from './parse-argv.js';
+export { default as parseEnv } from './parse-env.js';
+export * from './utils.js';

package/dist/lib/index.js

@@ -0,0 +1,5 @@
+export * from './const.js';
+export { default as loadEnv } from './env.js';
+export { default as parseArgv } from './parse-argv.js';
+export { default as parseEnv } from './parse-env.js';
+export * from './utils.js';

package/dist/lib/logger.d.ts

@@ -0,0 +1,9 @@
+export declare function info(message: string): void;
+export declare function warn(message: string): void;
+export declare function error(message: string): void;
+declare const _default: {
+    info: typeof info;
+    warn: typeof warn;
+    error: typeof error;
+};
+export default _default;

package/dist/lib/logger.js

@@ -0,0 +1,72 @@
+const Style = Object.freeze({
+    Background: {
+        Black: '\x1b[40m',
+        Red: '\x1b[41m',
+        Green: '\x1b[42m',
+        Yellow: '\x1b[43m',
+        Blue: '\x1b[44m',
+        Magenta: '\x1b[45m',
+        Cyan: '\x1b[46m',
+        White: '\x1b[47m',
+        Gray: '\x1b[100m',
+        BrightRed: '\x1b[101m',
+        BrightGreen: '\x1b[102m',
+        BrightYellow: '\x1b[103m',
+        BrightBlue: '\x1b[104m',
+        BrightMagenta: '\x1b[105m',
+        BrightCyan: '\x1b[106m',
+        BrightWhite: '\x1b[107m'
+    },
+    Foreground: {
+        Black: '\x1b[30m',
+        Red: '\x1b[31m',
+        Green: '\x1b[32m',
+        Yellow: '\x1b[33m',
+        Blue: '\x1b[34m',
+        Magenta: '\x1b[35m',
+        Cyan: '\x1b[36m',
+        White: '\x1b[37m',
+        Gray: '\x1b[90m',
+        BrightRed: '\x1b[91m',
+        BrightGreen: '\x1b[92m',
+        BrightYellow: '\x1b[93m',
+        BrightBlue: '\x1b[94m',
+        BrightMagenta: '\x1b[95m',
+        BrightCyan: '\x1b[96m',
+        BrightWhite: '\x1b[97m'
+    },
+    Bold: '\x1b[1m',
+    Inverse: '\x1b[7m',
+    Reset: '\x1b[0m',
+    Underscore: '\x1b[4m'
+});
+function _log({ task, message, data, style }) {
+    const now = new Date();
+    const ts = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}:${now.getSeconds().toString().padStart(2, '0')}`;
+    const msg = [`${Style.Foreground.Gray}${ts}${Style.Reset}`];
+    if (task) {
+        msg.push(`${Style.Foreground.Cyan}[${task}]${Style.Reset}`);
+    }
+    msg.push(`${style ?? Style.Reset}${message}${Style.Reset}`);
+    if (data) {
+        msg.push(`${Style.Foreground.Yellow}${data}${Style.Reset}`);
+    }
+    console.log(msg.join(' '));
+}
+export function info(message) {
+    _log({ message, style: Style.Foreground.White });
+    // _log({ task, message, data, style: Style.Foreground.White });
+}
+export function warn(message) {
+    _log({ message, style: Style.Foreground.Yellow });
+    // _log({ task, message, data, style: Style.Foreground.Yellow });
+}
+export function error(message) {
+    _log({ message, style: Style.Foreground.Red });
+    // _log({ task, message, data, style: Style.Foreground.Red });
+}
+export default {
+    info,
+    warn,
+    error
+};

package/dist/lib/parse-argv.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Parses process.argv or any string[] into an object with the given schema
+ * Properties should be prefixed with `--`
+ * Values should come immediately after the property and be separated by a space or `=`
+ * Type `array` can only be a array of `boolean`, `number`, or `string` types
+ * Type `boolean` will be `true` if present and not followed by `=[VALUE]`
+ * Type `object` property values can only by of `boolean`, `number`, or `string` types
+ * Schema entries may also be string‑literal arrays, which are treated as enum
+ * definitions; the resulting value will be typed as the union of the literals.
+ *
+ * @example
+ * const argv = parseArgv({
+ *   a: 'array',
+ *   b: 'boolean',
+ *   b2: 'boolean',
+ *   f: 'float',
+ *   n: 'number',
+ *   o: 'object',
+ *   s: 'string',
+ *   mode: ['dev','prod'] as const // enum-style union
+ * })
+ *
+ * > npm run build -- --a [one,2,false] --b --b2=false --f 3.14 --n 123 --o {one:1,nope:false,hello:world} --s mystring --mode dev
+ *
+ */
+type Type = 'array' | 'boolean' | 'float' | 'number' | 'object' | 'string';
+type Schema<S extends Record<string, Type | readonly string[]>> = {
+    [K in keyof S]: S[K] extends readonly (infer U)[] ? U | undefined : S[K] extends 'array' ? any[] | undefined : S[K] extends 'boolean' ? boolean | undefined : S[K] extends 'float' ? number | undefined : S[K] extends 'number' ? number | undefined : S[K] extends 'object' ? Record<string, any> | undefined : S[K] extends 'string' ? string | undefined : string | undefined;
+};
+export default function <S extends Record<string, Type | readonly string[]>>(schema: S, argv?: string[]): Schema<S>;
+export {};

package/dist/lib/parse-argv.js

@@ -0,0 +1,109 @@
+/**
+ * Parses process.argv or any string[] into an object with the given schema
+ * Properties should be prefixed with `--`
+ * Values should come immediately after the property and be separated by a space or `=`
+ * Type `array` can only be a array of `boolean`, `number`, or `string` types
+ * Type `boolean` will be `true` if present and not followed by `=[VALUE]`
+ * Type `object` property values can only by of `boolean`, `number`, or `string` types
+ * Schema entries may also be string‑literal arrays, which are treated as enum
+ * definitions; the resulting value will be typed as the union of the literals.
+ *
+ * @example
+ * const argv = parseArgv({
+ *   a: 'array',
+ *   b: 'boolean',
+ *   b2: 'boolean',
+ *   f: 'float',
+ *   n: 'number',
+ *   o: 'object',
+ *   s: 'string',
+ *   mode: ['dev','prod'] as const // enum-style union
+ * })
+ *
+ * > npm run build -- --a [one,2,false] --b --b2=false --f 3.14 --n 123 --o {one:1,nope:false,hello:world} --s mystring --mode dev
+ *
+ */
+export default function (schema, argv = process.argv.slice(2)) {
+    const data = {};
+    const args = argv.slice()
+        .map((arg) => { return arg?.trim(); })
+        .filter(arg => typeof arg == 'string' && arg !== '');
+    for (let i = 0; i < args.length; i++) {
+        if (args[i].startsWith('--')) {
+            const arg = args[i].slice(2);
+            if (arg.indexOf('=') !== -1) {
+                let [key, value] = arg.split('=');
+                if (schema[key]) {
+                    value = parseValue(schema[key], value);
+                    data[key] = value;
+                }
+            }
+            else if (schema[arg] === 'boolean') {
+                data[arg] = true;
+            }
+            else if (schema[arg]) {
+                let value = true;
+                if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+                    value = parseValue(schema[arg], args[++i]);
+                }
+                data[arg] = value;
+            }
+        }
+    }
+    return data;
+}
+function parseValue(type, value) {
+    if (typeof value != 'string') {
+        return undefined;
+    }
+    if (Array.isArray(type)) {
+        return (type.includes(value) ? value : value);
+    }
+    switch (type) {
+        case 'array': {
+            if (value.startsWith('[')) {
+                value = value.substring(1);
+            }
+            if (value.endsWith(']')) {
+                value = value.slice(0, -1);
+            }
+            const items = value.split(',')
+                .map((v) => {
+                v = v.trim();
+                if (/(true|false|\d+(?:\.\d+)?)/i.test(v)) {
+                    return JSON.parse(v);
+                }
+                else {
+                    return v;
+                }
+            });
+            return items;
+        }
+        case 'boolean':
+            return value.toLowerCase() === 'true' || value === '1';
+        case 'float':
+            return parseFloat(value);
+        case 'number':
+            return parseInt(value, 10);
+        case 'object':
+            if (value.startsWith('{') && value.endsWith('}')) {
+                const obj = value.substring(1, value.length - 1)
+                    .split(',')
+                    .filter(p => p.trim() !== '')
+                    .map((pair) => {
+                    let [key, val] = pair.split(':').map(s => s.trim());
+                    if (/(true|false|\d+(?:\.\d+)?)/i.test(val)) {
+                        val = JSON.parse(val);
+                    }
+                    return [key, val];
+                });
+                return Object.fromEntries(obj);
+            }
+            else {
+                return {};
+            }
+        case 'string':
+        default:
+            return value;
+    }
+}

package/dist/lib/parse-env.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Parses a .env file into an object with the given schema
+ * Values should come immediately after the property and be separated by `=`
+ * Values can be quoted or unquoted
+ * Type `array` can only be a array of `boolean`, `number`, or `string` types
+ * Type `object` property values can only by of `boolean`, `number`, or `string` types
+ * Schema entries may also be string‑literal arrays, which are treated as enum
+ * definitions; the resulting value will be typed as the union of the literals.
+ *
+ * @example
+ * import parseEnv from './parse-env';
+ *
+ * const env = parseEnv({
+ *   a: 'array',
+ *   b: 'boolean',
+ *   b2: 'boolean',
+ *   f: 'float',
+ *   n: 'number',
+ *   o: 'object',
+ *   s: 'string',
+ *   mode: ['dev','prod'] as const // enum-style union
+ * })
+ *
+ *
+ * // .env
+ * a="[1,2,3]"
+ * b=false
+ * b2="true"
+ * f="1.23"
+ * n=234
+ * o={"test":1}
+ * s="testing 1 2 3"
+ * mode=prod
+ */
+export type EnvPropertyType = 'array' | 'boolean' | 'float' | 'number' | 'object' | 'string';
+export type EnvSchema<S extends Record<string, EnvPropertyType | readonly string[]> = Record<string, any>> = {
+    [K in keyof S]: S[K] extends readonly (infer U)[] ? U | undefined : S[K] extends 'array' ? any[] | undefined : S[K] extends 'boolean' ? boolean | undefined : S[K] extends 'float' ? number | undefined : S[K] extends 'number' ? number | undefined : S[K] extends 'object' ? Record<string, any> | undefined : S[K] extends 'string' ? string | undefined : string | undefined;
+};
+declare function parseEnv<S extends Record<string, EnvPropertyType | readonly string[]>>(schema: S, { mode, cwd, filePath, all }?: {
+    mode?: string;
+    cwd?: string;
+    filePath?: string;
+    all?: boolean;
+}): Promise<EnvSchema<S>>;
+export default parseEnv;

package/dist/lib/parse-env.js

@@ -0,0 +1,124 @@
+/**
+ * Parses a .env file into an object with the given schema
+ * Values should come immediately after the property and be separated by `=`
+ * Values can be quoted or unquoted
+ * Type `array` can only be a array of `boolean`, `number`, or `string` types
+ * Type `object` property values can only by of `boolean`, `number`, or `string` types
+ * Schema entries may also be string‑literal arrays, which are treated as enum
+ * definitions; the resulting value will be typed as the union of the literals.
+ *
+ * @example
+ * import parseEnv from './parse-env';
+ *
+ * const env = parseEnv({
+ *   a: 'array',
+ *   b: 'boolean',
+ *   b2: 'boolean',
+ *   f: 'float',
+ *   n: 'number',
+ *   o: 'object',
+ *   s: 'string',
+ *   mode: ['dev','prod'] as const // enum-style union
+ * })
+ *
+ *
+ * // .env
+ * a="[1,2,3]"
+ * b=false
+ * b2="true"
+ * f="1.23"
+ * n=234
+ * o={"test":1}
+ * s="testing 1 2 3"
+ * mode=prod
+ */
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from 'node:path';
+// parse reads a .env file according to the given schema.  In addition to
+// the primitive types listed above the schema may use a string-literal
+// array to describe an enum; the returned object will then have the property
+// typed as the union of those literals.
+async function parseEnv(schema, { mode, cwd, filePath, all = false } = {}) {
+    const env = {};
+    const fp = filePath ? cwd ? join(cwd, filePath) : filePath : join(cwd ?? process.cwd(), `.env${mode ? `.${mode}` : ''}`);
+    if (existsSync(fp)) {
+        const data = {};
+        const content = await readFile(fp, 'utf8');
+        const lines = content.split(/\r?\n/).filter(l => l.trim() !== '');
+        for (const line of lines) {
+            const [key, value] = line.split('=');
+            data[key.trim()] = value.trim().match(/['"']?([^'"]*)['"]?/)?.[1].trim() ?? '';
+        }
+        for (const [key, value] of Object.entries(data)) {
+            if (schema[key]) {
+                env[key] = parseValue(schema[key], value);
+            }
+            else if (all) {
+                env[key] = value;
+            }
+        }
+    }
+    return env;
+}
+;
+function parseValue(type, value) {
+    if (typeof value != 'string') {
+        return undefined;
+    }
+    // enums are defined as string literal arrays in the schema
+    if (Array.isArray(type)) {
+        // return the value directly; optionally we could validate, but at runtime
+        // we simply cast back to one of the allowed values (union type ensures
+        // callers only use valid strings at compile time if schema is const).
+        return (type.includes(value) ? value : value);
+    }
+    switch (type) {
+        case 'array': {
+            if (value.startsWith('[')) {
+                value = value.substring(1);
+            }
+            if (value.endsWith(']')) {
+                value = value.slice(0, -1);
+            }
+            const items = value.split(',')
+                .map((v) => {
+                v = v.trim();
+                if (/(true|false|\d+(?:\.\d+)?)/i.test(v)) {
+                    return JSON.parse(v);
+                }
+                else {
+                    return v;
+                }
+            });
+            return items;
+        }
+        case 'boolean':
+            return value.toLowerCase() === 'true' || value === '1';
+        case 'float':
+            return parseFloat(value);
+        case 'number':
+            return parseInt(value, 10);
+        case 'object':
+            if (value.startsWith('{') && value.endsWith('}')) {
+                const obj = value.substring(1, value.length - 1)
+                    .split(',')
+                    .filter(p => p.trim() !== '')
+                    .map((pair) => {
+                    let [key, val] = pair.split(':').map(s => s.trim());
+                    if (/(true|false|\d+(?:\.\d+)?)/i.test(val)) {
+                        val = JSON.parse(val);
+                    }
+                    return [key, val];
+                });
+                return Object.fromEntries(obj);
+            }
+            else {
+                return {};
+            }
+        case 'string':
+        default:
+            return value;
+    }
+}
+export default parseEnv;

package/dist/lib/utils.d.ts

@@ -0,0 +1,8 @@
+import { DataEvotrk } from '../types';
+export declare function formatExtId(...ids: string[]): string;
+export declare function pathToSlideZip(path: string): string;
+export declare function flattenPath(path: string, { slashes }?: {
+    slashes?: boolean;
+}): string;
+export declare function urlToId(url: string | URL, separator?: string): string;
+export declare function dataEvotrkToString(data: DataEvotrk): string;

package/dist/lib/utils.js

@@ -0,0 +1,37 @@
+export function formatExtId(...ids) {
+    return ids.map((id) => { return id.toUpperCase(); }).join('_');
+}
+export function pathToSlideZip(path) {
+    return `${flattenPath(path, { slashes: false })}.zip`;
+}
+export function flattenPath(path, { slashes = true } = {}) {
+    return `${slashes ? '/' : ''}${path.toLowerCase().split('/').filter(s => s !== '').join('-')}${slashes ? '/' : ''}`;
+}
+export function urlToId(url, separator = '_') {
+    return (url instanceof URL ? url.pathname : url).split('/').filter(s => s !== '').map((s) => { return s.toLowerCase().replace(/[^0-9a-z_]/g, separator); }).join(separator);
+}
+export function dataEvotrkToString(data) {
+    data.slide = data.slide ?? '';
+    data.type = data.type ?? '';
+    data.name = data.name ?? '';
+    return Object.entries((data))
+        .sort(([key1], [key2]) => {
+        if (key1 === 'slide')
+            return -1;
+        if (key2 === 'slide')
+            return 1;
+        if (key1 === 'type')
+            return -1;
+        if (key2 === 'type')
+            return 1;
+        if (key1 === 'name')
+            return -1;
+        if (key2 === 'name')
+            return 1;
+        return 0;
+    })
+        .map(([key, value]) => {
+        return value;
+    })
+        .join('|');
+}

package/dist/tasks/copy-files.d.ts

@@ -0,0 +1,9 @@
+import type { IVeevaConfig } from '../types';
+interface Params {
+    config: IVeevaConfig;
+    rootDir: string;
+    astroDistDir: string;
+    deployDir: string;
+}
+export default function ({ config, rootDir, astroDistDir, deployDir }: Params): Promise<void>;
+export {};

package/dist/tasks/copy-files.js

@@ -0,0 +1,15 @@
+import { cp, readdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import logger from '../lib/logger.js';
+export default async function ({ config, rootDir, astroDistDir, deployDir }) {
+    logger.info(`Copying files to ${deployDir.replace(rootDir, '')}`);
+    const dirContent = await readdir(astroDistDir, { withFileTypes: true });
+    for (const c of dirContent) {
+        if (c.isDirectory() && (c.name === 'shared' || config.presentation.slides.find(s => s.path === c.name))) {
+            await cp(join(c.parentPath, c.name), join(deployDir, c.name), { recursive: true });
+            if (c.name === 'shared') {
+                writeFile(join(deployDir, c.name, 'index.html'), `<html><head><meta charset="UTF-8"><title>${config.presentation.name} - Shared Resource</title></head><body><h1>${config.presentation.name} - Shared Resource</h1></body></html>`);
+            }
+        }
+    }
+}

package/dist/tasks/create-csv.d.ts

@@ -0,0 +1,15 @@
+import type { IVeevaConfig } from '../types';
+interface Params {
+    config: IVeevaConfig;
+    deployDir: string;
+    buildName: string;
+    fieldsOnly?: boolean;
+    additional?: {
+        headers: string[];
+        presentation: string[];
+        slides: string[][];
+        shared: string[];
+    };
+}
+export default function ({ config, deployDir, buildName, fieldsOnly, additional }: Params): Promise<void>;
+export {};