@inizioevoke/veeva-astroclm-core 1.0.0

package/.editorconfig

@@ -0,0 +1,12 @@
+# EditorConfig is awesome: https://EditorConfig.org
+
+# top-most EditorConfig file
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = false
+insert_final_newline = false

package/build.ts

@@ -0,0 +1,38 @@
+import { cp, readdir, rm } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import parseArgv from './src/lib/parse-argv';
+
+async function clean() {
+  const dist = join(import.meta.dirname, 'dist');
+  if (existsSync(dist)) {
+    const files = await readdir(dist);
+
+    await Promise.all(
+      files.map((f) => {
+        return rm(join(dist, f), { recursive: true, force: true });
+      })
+    );
+  }
+}
+
+const argv = parseArgv({
+  'cmd': ['pre', 'post'] as const
+});
+
+switch (argv.cmd) {
+  case 'pre':
+    await clean();
+    break;
+  case 'post':
+    const dirsToCopy = [
+      'apps/page-manager/templates',
+      'apps/veeva-config-manager/templates',
+      'types'
+    ];
+    for (const dir of dirsToCopy) {
+      await cp(join(import.meta.dirname, 'src', dir), join(import.meta.dirname, 'dist', dir), { recursive: true });
+    }
+    break;
+}
+

package/dist/apps/index.d.ts

@@ -0,0 +1,2 @@
+export { default as pageManager } from './page-manager/index.js';
+export { default as veevaConfigManager } from './veeva-config-manager/index.js';

package/dist/apps/index.js

@@ -0,0 +1,2 @@
+export { default as pageManager } from './page-manager/index.js';
+export { default as veevaConfigManager } from './veeva-config-manager/index.js';

package/dist/apps/page-manager/bulk-create.d.ts

@@ -0,0 +1 @@
+export default function bulkCreate(rootDir: string): Promise<void>;

package/dist/apps/page-manager/bulk-create.js

@@ -0,0 +1,120 @@
+import { existsSync } from 'node:fs';
+import { readFile, rm } from 'node:fs/promises';
+import { join, resolve as resolvePath } from 'node:path';
+import { parse } from 'yaml';
+import { text, select, spinner, outro, box } from '@clack/prompts';
+import { sleep, handleCanceled } from '../utils.js';
+import { createPageAssets, getLayouts } from './utils.js';
+const __dirname = import.meta.dirname;
+export default async function bulkCreate(rootDir) {
+    const contentDir = join(rootDir, 'src/contents');
+    const pagesDir = join(rootDir, 'src/pages');
+    const bulkPath = handleCanceled(await text({
+        message: 'Enter the path, relative to the project root, of the YAML file containing the content to create',
+        initialValue: '_contents.yml',
+        validate: (value) => {
+            if (!value?.trim())
+                return 'The path is required';
+            if (!existsSync(resolvePath(rootDir, value.trim())))
+                return 'The file does not exist';
+            return undefined;
+        }
+    }));
+    const layouts = await getLayouts(rootDir);
+    const layout = handleCanceled(await select({
+        message: 'Select the layout each page should use',
+        options: (() => {
+            return layouts.map((layout) => {
+                const label = layout.replace(/\\/g, '/');
+                return {
+                    label,
+                    value: label
+                };
+            });
+        })()
+    }));
+    const created = [];
+    const existing = [];
+    const errors = [];
+    const spin = spinner();
+    spin.start('Generating page assets...');
+    await sleep();
+    const data = parse(await readFile(resolvePath(rootDir, bulkPath), 'utf8'))
+        .map((d) => { return d.trim(); });
+    for (const contentPath of data) {
+        if (existsSync(join(contentDir, contentPath)) && existsSync(join(pagesDir, `${contentPath.replace(/\//g, '-')}.astro`))) {
+            existing.push(contentPath);
+            spin.message(`Exists: ${contentPath}`);
+            await sleep();
+        }
+        else {
+            try {
+                await createPageAssets({ rootDir, contentPath, layout });
+                created.push(contentPath);
+                spin.message(`Generated: ${contentPath}`);
+            }
+            catch (err) {
+                errors.push(contentPath);
+                spin.message(`Error: ${contentPath}`);
+            }
+            await sleep();
+        }
+    }
+    spin.stop('Page assets generated!');
+    const result = [];
+    let insertNewLine = false;
+    if (created.length) {
+        result.push('The following content/pages were created:');
+        created.sort();
+        for (const c of created) {
+            result.push(` - ${c}`);
+        }
+        insertNewLine = true;
+    }
+    if (existing.length) {
+        if (insertNewLine) {
+            result.push('');
+        }
+        result.push('The following content/pages already exist:');
+        existing.sort();
+        for (const c of existing) {
+            result.push(` - ${c}`);
+        }
+        insertNewLine = true;
+    }
+    if (errors.length) {
+        if (insertNewLine) {
+            result.push('');
+        }
+        result.push('The following content/pages experienced an error while creating:');
+        errors.sort();
+        for (const c of errors) {
+            result.push(` - ${c}`);
+        }
+        insertNewLine = true;
+    }
+    box(result.join('\n'));
+    const deleteFile = handleCanceled(await select({
+        message: `Would you like to delete ${bulkPath}?`,
+        options: [{
+                label: 'Yes, delete the file',
+                value: true
+            }, {
+                label: 'No, keep the file',
+                value: false
+            }]
+    }));
+    if (deleteFile) {
+        const deleteSpinner = spinner();
+        deleteSpinner.start(`Deleting ${bulkPath}`);
+        await sleep();
+        try {
+            await rm(resolvePath(rootDir, bulkPath), { force: true });
+            deleteSpinner.stop('File deleted');
+        }
+        catch (err) {
+            deleteSpinner.error('An error occurred while attempting to delete the file');
+        }
+    }
+    outro('Happy coding!');
+}

package/dist/apps/page-manager/index.d.ts

@@ -0,0 +1,5 @@
+interface Opts {
+    root?: string;
+}
+export default function ({ root }?: Opts): Promise<void>;
+export {};

package/dist/apps/page-manager/index.js

@@ -0,0 +1,24 @@
+import { intro, select } from '@clack/prompts';
+import { handleCanceled } from '../utils.js';
+export default async function ({ root } = {}) {
+    const rootDir = root ?? process.cwd();
+    intro('Page Manager');
+    const action = handleCanceled(await select({
+        message: 'How would you like to create pages?',
+        options: [{
+                label: 'One at a time',
+                value: 'single'
+            }, {
+                label: 'Bulk create',
+                value: 'bulk'
+            }]
+    }));
+    if (action === 'bulk') {
+        const bulkCreate = await import('./bulk-create.js');
+        await bulkCreate.default(rootDir);
+    }
+    else {
+        const singleCreate = await import('./single-create.js');
+        await singleCreate.default(rootDir);
+    }
+}

package/dist/apps/page-manager/single-create.d.ts

@@ -0,0 +1 @@
+export default function singleCreate(rootDir: string): Promise<void>;

package/dist/apps/page-manager/single-create.js

@@ -0,0 +1,78 @@
+import { existsSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { text, select, note, spinner } from '@clack/prompts';
+import { sleep, handleCanceled } from '../utils.js';
+import { getLayouts, createPageAssets } from './utils.js';
+export default async function singleCreate(rootDir) {
+    const contentDir = join(rootDir, 'src/contents');
+    const pagesDir = join(rootDir, 'src/pages');
+    const layouts = await getLayouts(rootDir);
+    note('Page content will be stored in /src/contents\nPage routes will be created in /src/pages');
+    const contentPath = handleCanceled(await text({
+        message: 'Enter the path for the new page content relative to /src/contents',
+        validate: (value) => {
+            if (!value?.trim()) {
+                return 'The content path is required';
+            }
+            const contentPath = value.trim();
+            if (existsSync(join(contentDir, contentPath))) {
+                return 'The content path already exists';
+            }
+            const pageName = contentPath.replace(/\//g, '-');
+            if (existsSync(join(pagesDir, `${pageName}.astro`))) {
+                return `The page /src/pages/${pageName}.astro already exists`;
+            }
+            return undefined;
+        }
+    }));
+    // const name = handleCanceled(await text({
+    //   message: 'Enter the name of the content file',
+    //   initialValue: `${basename(path)}.astro`
+    // }));
+    // const pageName = handleCanceled(await text({
+    //   message: 'Enter the name of the page',
+    //   initialValue: `${path.toLowerCase().replace(/\//g, '-')}.astro`
+    // }));
+    const contentName = `${basename(contentPath)}`;
+    const pageName = `${contentPath.toLowerCase().replace(/\//g, '-')}.astro`;
+    const layout = handleCanceled(await select({
+        message: 'Select the layout the page should use',
+        options: (() => {
+            return layouts.map((layout) => {
+                const label = layout.replace(/\\/g, '/');
+                return {
+                    label,
+                    value: label
+                };
+            });
+        })()
+    }));
+    const spin = spinner();
+    spin.start('Generating page assets');
+    await sleep();
+    await createPageAssets({ rootDir, contentPath, contentName, pageName, layout });
+    await sleep();
+    spin.stop('Page assets generated!');
+    // let path: string | undefined = undefined;
+    // do {
+    //   path = handleCanceled(await text({
+    //     message: 'Enter the path for the new page content relative to /src/contents',
+    //     validate: (value: string | undefined) => {
+    //       if (!value?.trim()) return 'The content path is required';
+    //       return undefined;
+    //     }
+    //   }));
+    //   const contentPath = path!.trim().toLowerCase();
+    //   console.log(join(contentDir, contentPath));
+    //   if (existsSync(join(contentDir, contentPath))) {
+    //     console.log('The content path already exists');
+    //     path = undefined;
+    //   }
+    //   const pageName = contentPath.replace(/\//g, '-');
+    //   console.log(join(pagesDir, `${pageName}.astro`));
+    //   if (existsSync(join(pagesDir, `${pageName}.astro`))) {
+    //     console.log(`The page /src/pages/${pageName}.astro already exists`);
+    //     path = undefined;
+    //   }
+    // } while (path === undefined);
+}

package/dist/apps/page-manager/templates/contents.astro.txt

@@ -0,0 +1,12 @@
+---
+import ##LAYOUT_NAME## from '@layouts/##LAYOUT_PATH##';
+
+import './##CONTENT_NAME##.scss';
+---
+<##LAYOUT_NAME##>
+  <!-- Insert page content here -->
+  
+  <script>
+    import './##CONTENT_NAME##';
+  </script>
+</##LAYOUT_NAME##>

package/dist/apps/page-manager/templates/page.astro.txt

@@ -0,0 +1,4 @@
+---
+import Page from '@contents/##CONTENTS_PATH##/##CONTENTS_NAME##.astro';
+---
+<Page />

package/dist/apps/page-manager/utils.d.ts

@@ -0,0 +1,10 @@
+export declare function getLayouts(rootDir: string): Promise<string[]>;
+interface CreateParams {
+    rootDir: string;
+    contentPath: string;
+    contentName?: string;
+    pageName?: string;
+    layout: string;
+}
+export declare function createPageAssets({ rootDir, contentPath, contentName, pageName, layout }: CreateParams): Promise<void>;
+export {};

package/dist/apps/page-manager/utils.js

@@ -0,0 +1,57 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+export async function getLayouts(rootDir) {
+    const layouts = await readdir(join(rootDir, 'src/layouts'), { recursive: true });
+    return layouts.filter(l => l.endsWith('.astro')).sort();
+}
+export async function createPageAssets({ rootDir, contentPath, contentName, pageName, layout }) {
+    const contentDir = join(rootDir, 'src/contents');
+    const pagesDir = join(rootDir, 'src/pages');
+    if (!contentName) {
+        contentName = basename(contentPath);
+    }
+    if (!pageName) {
+        pageName = `${contentPath
+            .split('/')
+            .map((p, i, arr) => {
+            if (i > 0) {
+                let str = p;
+                // prevent the page name from having repeated words like "dir-dir-1"
+                if (p.startsWith(arr[i - 1]) && p.length > arr[i - 1].length + 1) {
+                    str = p.substring(arr[i - 1].length);
+                    if (/[0-9a-z]/i.test(str[0])) {
+                        return str;
+                    }
+                    else {
+                        return str.substring(str.match(/[0-9a-z]/i)?.index ?? 0);
+                    }
+                }
+                return str;
+            }
+            else {
+                return p;
+            }
+        })
+            .join('-')}.astro`;
+        if (existsSync(join(pagesDir, pageName))) {
+            pageName = `${contentPath.replace(/\//g, '-')}.astro`;
+        }
+    }
+    let pageTemplate = await readFile(join(import.meta.dirname, 'templates/page.astro.txt'), 'utf8');
+    pageTemplate = pageTemplate
+        .replace(/##CONTENTS_PATH##/g, contentPath)
+        .replace(/##CONTENTS_NAME##/g, contentName);
+    await writeFile(join(pagesDir, pageName), pageTemplate);
+    let contentTemplate = await readFile(join(import.meta.dirname, 'templates/contents.astro.txt'), 'utf8');
+    contentTemplate = contentTemplate
+        .replace(/##LAYOUT_NAME##/g, basename(layout).replace(/\.astro$/, ''))
+        .replace(/##LAYOUT_PATH##/g, layout)
+        .replace(/##CONTENT_NAME##/g, contentName);
+    if (!existsSync(join(contentDir, contentPath))) {
+        await mkdir(join(contentDir, contentPath), { recursive: true });
+    }
+    await writeFile(join(contentDir, contentPath, `${contentName}.astro`), contentTemplate);
+    await writeFile(join(contentDir, contentPath, `${contentName}.scss`), '');
+    await writeFile(join(contentDir, contentPath, `${contentName}.ts`), '');
+}

package/dist/apps/utils.d.ts

@@ -0,0 +1,5 @@
+export declare function sleep(timeout?: number): Promise<unknown>;
+export declare function handleCanceled<T = string>(value: unknown): T;
+export declare function cleanInput(value: string): string;
+export declare const generateRandomId: (length?: number) => string;
+export declare function titleCase(value: string): string;

package/dist/apps/utils.js

@@ -0,0 +1,43 @@
+import { getRandomValues } from 'node:crypto';
+import { isCancel, cancel } from '@clack/prompts';
+export function sleep(timeout = 500) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeout);
+    });
+}
+export function handleCanceled(value) {
+    if (isCancel(value)) {
+        cancel('Canceled');
+        process.exit(0);
+    }
+    else {
+        return value;
+    }
+}
+export function cleanInput(value) {
+    return value.trim().replace(/  /g, ' ');
+}
+export const generateRandomId = (() => {
+    function chars(count) {
+        return [...getRandomValues(new Uint16Array(count))]
+            .map((n) => {
+            return n.toString(36).toUpperCase();
+        })
+            .join('');
+    }
+    return (length = 8) => {
+        let id = chars(Math.round(length / 4) + 1);
+        while (id.length < length) {
+            id += chars(1);
+        }
+        return id.substring(0, length);
+    };
+})();
+export function titleCase(value) {
+    return value.split('-')
+        .filter(v => v.trim() !== '')
+        .map((v) => {
+        return `${v[0].toUpperCase()}${v.substring(1)}`;
+    })
+        .join(' ');
+}

package/dist/apps/veeva-config-manager/create.d.ts

@@ -0,0 +1 @@
+export default function (rootDir: string): Promise<void>;

package/dist/apps/veeva-config-manager/create.js

@@ -0,0 +1,136 @@
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { join, resolve as resolvePath } from 'node:path';
+import { text, select, multiselect, spinner, outro } from '@clack/prompts';
+import { sleep, handleCanceled, cleanInput, generateRandomId, titleCase } from '../utils.js';
+const __dirname = import.meta.dirname;
+export default async function (rootDir) {
+    const product = handleCanceled(await text({
+        message: 'Enter the product name',
+        validate: (value) => {
+            if (!value?.trim())
+                return 'Product name is required';
+            return undefined;
+        }
+    }));
+    const presentation = handleCanceled(await text({
+        message: 'Enter a presentation name',
+        validate: (value) => {
+            if (!value?.trim())
+                return 'Presentation name is required';
+            return undefined;
+        }
+    }));
+    const presentationId = handleCanceled(await text({
+        message: 'Enter a presentation ID',
+        initialValue: presentation.toString().toLowerCase().replace(/[^0-9a-z_]/g, '_'),
+        validate: (value) => {
+            if (!value?.trim())
+                return 'Presentation ID is required';
+            return undefined;
+        }
+    }));
+    const dimensions = handleCanceled(await select({
+        message: 'Select the IVA dimensions',
+        options: [{
+                label: '1024 x 768',
+                value: '1024_768'
+            }, {
+                label: '1366 x 1024',
+                value: '1366_1024'
+            }, {
+                label: '1376 x 1032',
+                value: '1376_1032'
+            }],
+        initialValue: '1366_1024'
+    }));
+    const [width, height] = dimensions.split('_');
+    const iosResolution = handleCanceled(await select({
+        message: 'Select the iOS resolution',
+        options: [{
+                label: 'Default For Device',
+                value: 'Default For Device'
+            }, {
+                label: 'Scale To Fit',
+                value: 'Scale To Fit'
+            }, {
+                label: 'Scale To 1024x768',
+                value: 'Scale To 1024x768'
+            }],
+        initialValue: 'Default For Device'
+    }));
+    const disableActions = handleCanceled(await multiselect({
+        message: 'Select any actions you would like to disable globally',
+        required: false,
+        options: [{
+                label: 'History Buttons',
+                value: 'History Buttons'
+            }, {
+                label: 'Navigation Bar',
+                value: 'Navigation Bar'
+            }, {
+                label: 'Pinch to Exit',
+                value: 'Pinch to Exit'
+            }, {
+                label: 'Reactions',
+                value: 'Reactions'
+            }, {
+                label: 'Rotation Lock',
+                value: 'Rotation Lock'
+            }, {
+                label: 'Swipe',
+                value: 'Swipe'
+            }, {
+                label: 'Zoom',
+                value: 'Zoom'
+            }]
+    }));
+    const crmTarget = handleCanceled(await select({
+        message: 'Select the Veeva platform version',
+        options: [{
+                label: 'Salesforce',
+                value: 'Salesforce'
+            }, {
+                label: 'Vault',
+                value: 'Vault'
+            }],
+        initialValue: 'Salesforce'
+    }));
+    const spin = spinner();
+    spin.start('Generating config file...');
+    await sleep(); // make it seem like we're doing something
+    const slides = [];
+    const slideIds = new Set();
+    const pages = await readdir(resolvePath(rootDir, 'src/pages'));
+    for (const page of pages) {
+        if (page.endsWith('.astro')) {
+            const p = page.slice(0, -6);
+            let slideId = generateRandomId();
+            while (slideIds.has(slideId)) {
+                slideId = generateRandomId();
+            }
+            slideIds.add(slideId);
+            slides.push(`{
+        path: '${p}',
+        title: '${titleCase(p)}',
+        externalId: formatExtId('${slideId}')
+      }`);
+        }
+    }
+    let template = await readFile(join(__dirname, 'templates/config.ts.txt'), 'utf8');
+    template = template
+        .replace(/##EXTERNAL_ID##/g, `${cleanInput(product).substring(0, 3).toUpperCase()}_${generateRandomId()}`)
+        .replace(/##PRODUCT##/g, cleanInput(product))
+        .replace(/##PRESENTATION_NAME##/g, cleanInput(presentation))
+        .replace(/##PRESENTATION_ID##/g, cleanInput(presentationId))
+        .replace(/##DIMENSIONS_WIDTH##/g, width)
+        .replace(/##DIMENSIONS_HEIGHT##/g, height)
+        .replace(/##IOS_RESOLUTION##/g, iosResolution)
+        .replace(/##DISABLE_ACTIONS##/g, `[${disableActions.map((a) => { return `'${a}'`; }).join(', ')}]`)
+        .replace(/##CRM_TARGET##/g, crmTarget)
+        .replace(/##SLIDES##/g, `[${slides.join(', ')}]`)
+        .replace(/##SLIDE_IDS##/g, [...slideIds].join());
+    await writeFile(resolvePath(rootDir, 'veeva-config.ts'), template);
+    await sleep(); // make it seem like we're doing something
+    spin.stop('Config file generated!');
+    outro('Happy coding!');
+}

package/dist/apps/veeva-config-manager/index.d.ts

@@ -0,0 +1,3 @@
+export default function ({ root }?: {
+    root?: string;
+}): Promise<void>;

package/dist/apps/veeva-config-manager/index.js

@@ -0,0 +1,16 @@
+import { existsSync } from 'node:fs';
+import { resolve as resolvePath } from 'node:path';
+import { intro } from '@clack/prompts';
+export default async function ({ root } = {}) {
+    const rootDir = root ?? process.cwd();
+    const exists = existsSync(resolvePath(rootDir, 'veeva-config.ts'));
+    console.log('');
+    intro('Veeva Configuration Manager');
+    if (!exists) {
+        const create = await import('./create.js');
+        await create.default(rootDir);
+    } /* else {
+      const update = await import('../../../archive/update');
+      await update.default();
+    } */
+}

package/dist/apps/veeva-config-manager/templates/config.ts.txt

@@ -0,0 +1,60 @@
+import type { IVeevaClmBinderFields, IVeevaConfig, VeevaEnv } from "@inizioevoke/veeva-astroclm-core/types";
+import { formatExtId as __formatExtId } from '@inizioevoke/veeva-astroclm-core/lib';
+
+interface IVeevaConfigArgs {
+  veevaEnv?: VeevaEnv;
+  isTraining?: boolean;
+}
+export default function ({ veevaEnv = 'client', isTraining = false }: IVeevaConfigArgs = {}): IVeevaConfig {
+  const isEvokeBuild = veevaEnv === 'evoke';
+  const EXT_ID = `##EXTERNAL_ID##${isTraining ? '_TRN' : ''}`;
+  const PRESENTATION_NAME = '##PRESENTATION_NAME##';
+
+  const formatExtId = (id: string) => {
+    return __formatExtId(EXT_ID, id);
+  };
+
+  const binderFields: IVeevaClmBinderFields = {
+    // language: isEvokeBuild ? undefined : 'English',
+    // crmOrg: isEvokeBuild ? undefined : { crmId: ['CRM_ORD_ID'] },
+    // crmProduct: isEvokeBuild ? undefined : { id: 'VEEVA_ID_FROM_URL' },
+    // crmDetailGroup: isEvokeBuild ? undefined : { id: 'VEEVA_ID_FROM_URL' },
+    // detailGroup: undefined
+  };
+
+  return {
+    dimensions: { width: ##DIMENSIONS_WIDTH##, height: ##DIMENSIONS_HEIGHT## },
+    thumbnails: {
+      default: {
+        queryStringParams: {
+          screenshots: true
+        }
+      }
+    },
+    presentation: {
+      externalId: EXT_ID,
+      presentationId: `##PRESENTATION_ID##${isTraining ? '_trn' : ''}`,
+      product: '##PRODUCT##',
+      name: `${PRESENTATION_NAME}${isTraining ? ' [Training]' : ''}`,
+      country: 'United States',
+      isTraining,
+      crmTarget: '##CRM_TARGET##',
+      ...binderFields,
+
+      shared: {
+        externalId: formatExtId('SHARED'),
+        ...binderFields
+      },
+
+      slideSettings: {
+        mediaType: 'HTML',
+        disableActions: ##DISABLE_ACTIONS##,
+        iosResolution: '##IOS_RESOLUTION##',
+        ...binderFields
+      },
+      slides: ##SLIDES##
+    }
+  };
+}
+
+// SLIDE_IDS: [##SLIDE_IDS##]