@inizioevoke/veeva-astroclm-core 1.0.0

package/dist/veeva/slideManager.js

@@ -0,0 +1,120 @@
+import fs from 'fs';
+import path from 'path';
+const configPath = path.resolve(__dirname, 'config.ts');
+function readConfig() {
+    return fs.readFileSync(configPath, 'utf8');
+}
+function writeConfig(text) {
+    fs.writeFileSync(configPath, text, 'utf8');
+}
+function mutateSlides(mutate) {
+    const content = readConfig();
+    const slidesSection = /slides\s*:\s*\[([\s\S]*?)\]/m;
+    const match = content.match(slidesSection);
+    if (!match) {
+        throw new Error('Unable to locate slides array in config.ts');
+    }
+    const before = content.slice(0, match.index);
+    const after = content.slice((match.index ?? 0) + match[0].length);
+    const current = match[1];
+    const updated = mutate(current);
+    const newSection = `slides: [${updated}]`;
+    writeConfig(before + newSection + after);
+}
+/**
+ * Create an editor instance that loads the slides section once and allows
+ * multiple mutations before committing the change back to disk.
+ */
+export function createEditor() {
+    const slidesSection = /slides\s*:\s*\[([\s\S]*?)\]/m;
+    let content = readConfig();
+    const match = content.match(slidesSection);
+    if (!match) {
+        throw new Error('Unable to locate slides array in config.ts');
+    }
+    const prefix = content.slice(0, match.index);
+    const suffix = content.slice((match.index ?? 0) + match[0].length);
+    let current = match[1];
+    function commit() {
+        const newSection = `slides: [${current}]`;
+        writeConfig(prefix + newSection + suffix);
+    }
+    function removePaths(targetPaths) {
+        if (targetPaths.length === 0)
+            return;
+        for (const p of targetPaths) {
+            const esc = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const re = new RegExp(`\{[\s\S]*?path:\s*['"]${esc}['"][\s\S]*?\}(,?)`, 'm');
+            current = current.replace(re, '');
+        }
+        current = current.replace(/,\s*,/g, ',');
+        current = current.replace(/,\s*$/m, '');
+    }
+    function insert(slide) {
+        const trimmed = current.trim();
+        const formatted = `
+      { path: '${slide.path}', title: '${slide.title}', externalId: '${slide.externalId}' }`;
+        if (trimmed === '') {
+            current = formatted + '\n';
+        }
+        else {
+            current = trimmed.replace(/\s*$/, '') + ',' + formatted + '\n';
+        }
+    }
+    function updatePath(oldPath, newPath) {
+        const escOld = oldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        current = current.replace(new RegExp(`(path:\s*['"])${escOld}(['"])`), `$1${newPath}$2`);
+    }
+    return {
+        removePaths,
+        insert,
+        updatePath,
+        commit,
+        // expose current for inspection/testing
+        getCurrent: () => current
+    };
+}
+/**
+ * Remove every slide whose `path` matches one of the provided keys.
+ */
+export function removeSlides(targetPaths) {
+    if (targetPaths.length === 0)
+        return;
+    mutateSlides(current => {
+        let txt = current;
+        for (const p of targetPaths) {
+            const esc = p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const re = new RegExp(`\{[\s\S]*?path:\s*['"]${esc}['"][\s\S]*?\}(,?)`, 'm');
+            txt = txt.replace(re, '');
+        }
+        // clean up extra commas
+        txt = txt.replace(/,\s*,/g, ',');
+        txt = txt.replace(/,\s*$/m, '');
+        return txt;
+    });
+}
+/**
+ * Append a slide object to the end of the slides array.  The caller should
+ * provide values already formatted as they should appear in the file (quotes
+ * around strings, etc.).  We simply ensure there is a comma between entries.
+ */
+export function insertSlide(slide) {
+    mutateSlides(current => {
+        const trimmed = current.trim();
+        const formatted = `
+      { path: '${slide.path}', title: '${slide.title}', externalId: '${slide.externalId}' }`;
+        if (trimmed === '') {
+            return formatted + '\n';
+        }
+        return trimmed.replace(/\s*$/, '') + ',' + formatted + '\n';
+    });
+}
+/**
+ * Change the `path` value of the first slide object that has `oldPath`.
+ */
+export function updateSlidePath(oldPath, newPath) {
+    mutateSlides(current => {
+        const escOld = oldPath.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        return current.replace(new RegExp(`(path:\s*['"])${escOld}(['"])`), `$1${newPath}$2`);
+    });
+}

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@inizioevoke/veeva-astroclm-core",
+  "version": "1.0.0",
+  "description": "",
+  "license": "ISC",
+  "author": "",
+  "type": "module",
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "npx tsx build.ts --cmd pre && tsc && npx tsx build.ts --cmd post"
+  },
+  "exports": {
+    "./apps": "./dist/apps/index.js",
+    "./integrations": "./dist/integrations/index.js",
+    "./lib": "./dist/lib/index.js",
+    "./tasks": "./dist/tasks/index.js",
+    "./types": "./dist/types/index.d.ts"
+  },
+  "peerDependencies": {
+    "astro": ">=5.0.0",
+    "typescript": ">=5.0.0"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.4.0",
+    "adm-zip": "^0.5.17",
+    "puppeteer": "^24.43.1",
+    "sharp": "^0.34.5"
+  },
+  "devDependencies": {
+    "@astrojs/check": "^0.9.9",
+    "@astrojs/ts-plugin": "^1.10.7",
+    "@types/adm-zip": "^0.5.8",
+    "@types/node": "^25.7.0",
+    "astro": "^6.3.1",
+    "tsx": "^4.21.0",
+    "typescript": "^6.0.3",
+    "yaml": "^2.9.0"
+  }
+}

package/src/apps/index.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/src/apps/page-manager/bulk-create.ts

@@ -0,0 +1,131 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, readdir, rm } from 'node:fs/promises';
+import { join, resolve as resolvePath } from 'node:path';
+
+import { parse } from 'yaml';
+
+import { intro, text, select, multiselect, note, spinner, outro, box } from '@clack/prompts';
+import { sleep, handleCanceled, cleanInput, generateRandomId, titleCase } from '../utils.js';
+import { createPageAssets, getLayouts } from './utils.js';
+
+const __dirname = import.meta.dirname;
+
+export default async function bulkCreate(rootDir: string) {
+  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: string | undefined) => {
+      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: string[] = [];
+  const existing: string[] = [];
+  const errors: string[] = [];
+
+  const spin = spinner();
+  spin.start('Generating page assets...');
+  await sleep();
+
+  const data = (parse(await readFile(resolvePath(rootDir, bulkPath), 'utf8')) as string[])
+                  .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: string[] = [];
+  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<boolean>(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/src/apps/page-manager/index.ts

@@ -0,0 +1,31 @@
+import { resolve } from 'node:path';
+import { intro, select } from '@clack/prompts';
+import { handleCanceled } from '../utils.js';
+
+interface Opts {
+  root?: string;
+}
+export default async function({ root }: Opts = {}) {
+  const rootDir = root ?? process.cwd();
+
+  intro('Page Manager');
+
+  const action = handleCanceled<'single' | 'bulk'>(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/src/apps/page-manager/single-create.ts

@@ -0,0 +1,97 @@
+import { existsSync } from 'node:fs';
+import { writeFile, readdir, readFile, mkdir } from 'node:fs/promises';
+import { basename, join, resolve as resolvePath } from 'node:path';
+
+import { text, select, multiselect, note, spinner, outro } from '@clack/prompts';
+import { sleep, handleCanceled, cleanInput, generateRandomId, titleCase } from '../utils.js';
+import { getLayouts, createPageAssets } from './utils.js';
+
+
+
+
+export default async function singleCreate(rootDir: string) {
+  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: string | undefined): string | undefined => {
+      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/src/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/src/apps/page-manager/templates/page.astro.txt

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

package/src/apps/page-manager/utils.ts

@@ -0,0 +1,70 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, readdir, mkdir } from 'node:fs/promises';
+import { basename, join, resolve as resolvePath } from 'node:path';
+
+export async function getLayouts(rootDir: string): Promise<string[]> {
+  const layouts = await readdir(join(rootDir, 'src/layouts'), { recursive: true });
+  return layouts.filter(l => l.endsWith('.astro')).sort();
+}
+
+interface CreateParams {
+  rootDir: string;
+  contentPath: string;
+  contentName?: string;
+  pageName?: string;
+  layout: string;
+}
+export async function createPageAssets({ rootDir, contentPath, contentName, pageName, layout }: CreateParams) {
+  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/src/apps/utils.ts

@@ -0,0 +1,47 @@
+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<T = string>(value: unknown): T {
+  if (isCancel(value)) {
+    cancel('Canceled');
+    process.exit(0);
+  } else {
+    return value as T;
+  }
+}
+
+export function cleanInput(value: string) {
+  return value.trim().replace(/  /g, ' ');
+}
+
+export const generateRandomId = (() => {
+  function chars(count: number) {
+    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: string) {
+  return value.split('-')
+    .filter(v => v.trim() !== '')
+    .map((v) => {
+      return `${v[0].toUpperCase()}${v.substring(1)}`
+    })
+    .join(' ');
+}