supaslidev 0.1.4 → 0.2.0

package/src/shared/catalog.ts

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { PackageJson } from './types.js';
+
+export const CATALOG_DEPENDENCIES = [
+  '@slidev/cli',
+  '@slidev/theme-default',
+  '@slidev/theme-seriph',
+  '@slidev/theme-apple-basic',
+  'vue',
+];
+
+export function hasSharedPackage(projectRoot: string): boolean {
+  const sharedPackagePath = join(projectRoot, 'packages', 'shared', 'package.json');
+  return existsSync(sharedPackagePath);
+}
+
+export function addSharedAddonToSlides(slidesPath: string): void {
+  const content = readFileSync(slidesPath, 'utf-8');
+  const frontmatterMatch = content.match(/^(---\n)([\s\S]*?)\n(---)/);
+  if (!frontmatterMatch) return;
+
+  const [fullMatch, openDelim, frontmatter, closeDelim] = frontmatterMatch;
+  const restOfFile = content.slice(fullMatch.length);
+  const sharedAddon = '@supaslidev/shared';
+
+  if (frontmatter.includes(sharedAddon)) return;
+
+  let updatedFrontmatter = frontmatter;
+
+  const addonsMatch = frontmatter.match(/^(addons:\s*)(\[.*?\])?$/m);
+  if (addonsMatch) {
+    if (addonsMatch[2]) {
+      const arrayContent = addonsMatch[2].slice(1, -1).trim();
+      if (arrayContent === '') {
+        updatedFrontmatter = frontmatter.replace(addonsMatch[0], `addons: ['${sharedAddon}']`);
+      } else {
+        updatedFrontmatter = frontmatter.replace(
+          addonsMatch[0],
+          `addons: [${arrayContent}, '${sharedAddon}']`,
+        );
+      }
+    } else {
+      const addonsBlockMatch = frontmatter.match(/^addons:\s*\n((?:  - .+\n?)*)/m);
+      if (addonsBlockMatch) {
+        const existingBlock = addonsBlockMatch[0].trimEnd();
+        updatedFrontmatter = frontmatter.replace(
+          existingBlock,
+          `${existingBlock}\n  - '${sharedAddon}'`,
+        );
+      } else {
+        updatedFrontmatter = frontmatter.replace(addonsMatch[0], `addons:\n  - '${sharedAddon}'`);
+      }
+    }
+  } else {
+    const themeMatch = frontmatter.match(/^(theme:\s*.+)$/m);
+    if (themeMatch) {
+      updatedFrontmatter = frontmatter.replace(
+        themeMatch[1],
+        `${themeMatch[1]}\naddons:\n  - '${sharedAddon}'`,
+      );
+    } else {
+      updatedFrontmatter = `${frontmatter}\naddons:\n  - '${sharedAddon}'`;
+    }
+  }
+
+  if (updatedFrontmatter !== frontmatter) {
+    writeFileSync(slidesPath, `${openDelim}${updatedFrontmatter}\n${closeDelim}${restOfFile}`);
+  }
+}
+
+export function addSharedDependencyToPackageJson(packageJson: PackageJson): void {
+  if (!packageJson.dependencies) {
+    packageJson.dependencies = {};
+  }
+  if (!packageJson.dependencies['@supaslidev/shared']) {
+    packageJson.dependencies['@supaslidev/shared'] = 'workspace:*';
+  }
+}
+
+export function convertToCatalogDependencies(
+  dependencies: Record<string, string>,
+): Record<string, string> {
+  if (!dependencies || typeof dependencies !== 'object') {
+    return {};
+  }
+  const converted = { ...dependencies };
+  for (const dep of CATALOG_DEPENDENCIES) {
+    if (dep in converted) {
+      converted[dep] = 'catalog:';
+    }
+  }
+  return converted;
+}

package/src/shared/copy.ts

@@ -0,0 +1,28 @@
+import { cpSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import { join, basename } from 'node:path';
+import { shouldIgnore } from './validation.js';
+
+export function copyDirectorySelective(source: string, destination: string): void {
+  mkdirSync(destination, { recursive: true });
+
+  const entries = readdirSync(source);
+
+  for (const entry of entries) {
+    if (shouldIgnore(entry)) {
+      continue;
+    }
+
+    const sourcePath = join(source, entry);
+    const destPath = join(destination, entry);
+    const stat = statSync(sourcePath);
+
+    if (stat.isDirectory()) {
+      cpSync(sourcePath, destPath, {
+        recursive: true,
+        filter: (src) => !shouldIgnore(basename(src)),
+      });
+    } else {
+      cpSync(sourcePath, destPath);
+    }
+  }
+}

package/src/shared/index.ts

@@ -0,0 +1,29 @@
+export type { Presentation, PackageJson, ValidationResult, PathValidationResult } from './types.js';
+
+export {
+  SLUG_REGEX,
+  IGNORE_PATTERNS,
+  isValidPresentationId,
+  validateName,
+  shouldIgnore,
+  validateSourceDirectory,
+  validateSourceDirectoryResult,
+  validatePath,
+  validatePaths,
+} from './validation.js';
+
+export {
+  parseFrontmatter,
+  extractDescription,
+  regeneratePresentationsJson,
+} from './presentations.js';
+
+export {
+  CATALOG_DEPENDENCIES,
+  hasSharedPackage,
+  addSharedAddonToSlides,
+  addSharedDependencyToPackageJson,
+  convertToCatalogDependencies,
+} from './catalog.js';
+
+export { copyDirectorySelective } from './copy.js';

package/{scripts/generate-presentations.mjs → src/shared/presentations.ts}

@@ -1,40 +1,16 @@
-#!/usr/bin/env node
+import { existsSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import type { Presentation } from './types.js';
 
-import { existsSync, readdirSync, readFileSync, statSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const packageDir = join(__dirname, '..');
-
-function resolveProjectRoot() {
-  if (process.env.SUPASLIDEV_PROJECT_ROOT) {
-    return process.env.SUPASLIDEV_PROJECT_ROOT;
-  }
-  return join(packageDir, '..', '..', '..');
-}
-
-function resolvePresentationsDir() {
-  if (process.env.SUPASLIDEV_PRESENTATIONS_DIR) {
-    return process.env.SUPASLIDEV_PRESENTATIONS_DIR;
-  }
-  return join(resolveProjectRoot(), 'presentations');
-}
-
-const projectRoot = resolveProjectRoot();
-const presentationsDir = resolvePresentationsDir();
-const outputDir = join(projectRoot, '.supaslidev');
-const outputFile = join(outputDir, 'presentations.json');
-
-function parseFrontmatter(content) {
+export function parseFrontmatter(content: string): Record<string, string> {
   const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
   if (!frontmatterMatch) return {};
 
   const frontmatter = frontmatterMatch[1];
-  const result = {};
+  const result: Record<string, string> = {};
 
-  let currentKey = null;
-  let currentValue = [];
+  let currentKey: string | null = null;
+  let currentValue: string[] = [];
   let inMultiline = false;
 
   const lines = frontmatter.split('\n');
@@ -42,7 +18,7 @@ function parseFrontmatter(content) {
   for (const line of lines) {
     if (inMultiline) {
       if (line.match(/^[a-zA-Z]/)) {
-        result[currentKey] = currentValue.join('\n').trim();
+        result[currentKey!] = currentValue.join('\n').trim();
         inMultiline = false;
         currentKey = null;
         currentValue = [];
@@ -77,7 +53,7 @@ function parseFrontmatter(content) {
   return result;
 }
 
-function extractDescription(info) {
+export function extractDescription(info: string | undefined): string {
   if (!info) return '';
   return info
     .replace(/^##?\s+.*$/gm, '')
@@ -88,17 +64,24 @@ function extractDescription(info) {
     .join(' ');
 }
 
-function getPresentations() {
+export function regeneratePresentationsJson(
+  presentationsDir: string,
+  presentationsJsonPath: string,
+): void {
   if (!existsSync(presentationsDir)) {
-    return [];
+    return;
   }
 
-  const dirs = readdirSync(presentationsDir).filter((name) => {
+  const allDirs = readdirSync(presentationsDir);
+
+  const dirs = allDirs.filter((name) => {
     const fullPath = join(presentationsDir, name);
-    return statSync(fullPath).isDirectory() && existsSync(join(fullPath, 'slides.md'));
+    const isDir = statSync(fullPath).isDirectory();
+    const hasSlides = existsSync(join(fullPath, 'slides.md'));
+    return isDir && hasSlides;
   });
 
-  return dirs
+  const presentations: Presentation[] = dirs
     .map((name) => {
       const slidesPath = join(presentationsDir, name, 'slides.md');
       const content = readFileSync(slidesPath, 'utf-8');
@@ -114,17 +97,11 @@ function getPresentations() {
       };
     })
     .sort((a, b) => a.title.localeCompare(b.title));
-}
-
-function main() {
-  const presentations = getPresentations();
 
+  const outputDir = dirname(presentationsJsonPath);
   if (!existsSync(outputDir)) {
     mkdirSync(outputDir, { recursive: true });
   }
 
-  writeFileSync(outputFile, JSON.stringify(presentations, null, 2));
-  console.log(`Generated ${outputFile} with ${presentations.length} presentations`);
+  writeFileSync(presentationsJsonPath, JSON.stringify(presentations, null, 2));
 }
-
-main();

package/src/shared/types.ts

@@ -0,0 +1,29 @@
+export interface Presentation {
+  id: string;
+  title: string;
+  description: string;
+  theme: string;
+  background: string;
+  duration: string;
+}
+
+export interface PackageJson {
+  name?: string;
+  private?: boolean;
+  scripts?: Record<string, string>;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  [key: string]: unknown;
+}
+
+export interface ValidationResult {
+  isValid: boolean;
+  error?: string;
+}
+
+export interface PathValidationResult {
+  path: string;
+  isValid: boolean;
+  suggestedName: string | null;
+  error: string | null;
+}

package/src/shared/validation.ts

@@ -0,0 +1,111 @@
+import { existsSync, statSync } from 'node:fs';
+import { join, basename, resolve } from 'node:path';
+import type { ValidationResult, PathValidationResult } from './types.js';
+
+export const SLUG_REGEX = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+
+export const IGNORE_PATTERNS = [
+  'node_modules',
+  '.git',
+  'dist',
+  '.nuxt',
+  '.output',
+  'pnpm-lock.yaml',
+  'package-lock.json',
+  'yarn.lock',
+  '.DS_Store',
+];
+
+export function isValidPresentationId(id: string): boolean {
+  return typeof id === 'string' && id.length > 0 && id.length <= 100 && SLUG_REGEX.test(id);
+}
+
+export function validateName(name: string): void {
+  if (!SLUG_REGEX.test(name)) {
+    throw new Error(
+      'Name must be lowercase alphanumeric with single hyphens only (no leading, trailing, or consecutive hyphens)',
+    );
+  }
+}
+
+export function shouldIgnore(name: string): boolean {
+  return IGNORE_PATTERNS.includes(name);
+}
+
+export function validateSourceDirectory(sourcePath: string): void {
+  if (!existsSync(sourcePath)) {
+    throw new Error(`Source directory does not exist: ${sourcePath}`);
+  }
+
+  if (!statSync(sourcePath).isDirectory()) {
+    throw new Error(`Source path is not a directory: ${sourcePath}`);
+  }
+
+  const slidesPath = join(sourcePath, 'slides.md');
+  if (!existsSync(slidesPath)) {
+    throw new Error(`No slides.md found in source directory: ${sourcePath}`);
+  }
+
+  const packageJsonPath = join(sourcePath, 'package.json');
+  if (!existsSync(packageJsonPath)) {
+    throw new Error(`No package.json found in source directory: ${sourcePath}`);
+  }
+}
+
+export function validateSourceDirectoryResult(sourcePath: string): ValidationResult {
+  try {
+    if (!existsSync(sourcePath)) {
+      return { isValid: false, error: 'Source directory does not exist' };
+    }
+
+    if (!statSync(sourcePath).isDirectory()) {
+      return { isValid: false, error: 'Source path is not a directory' };
+    }
+
+    const slidesPath = join(sourcePath, 'slides.md');
+    if (!existsSync(slidesPath)) {
+      return { isValid: false, error: 'No slides.md found in source directory' };
+    }
+
+    const packageJsonPath = join(sourcePath, 'package.json');
+    if (!existsSync(packageJsonPath)) {
+      return { isValid: false, error: 'No package.json found in source directory' };
+    }
+
+    return { isValid: true };
+  } catch (err) {
+    return { isValid: false, error: `Validation error: ${(err as Error).message}` };
+  }
+}
+
+export function validatePath(path: string): PathValidationResult {
+  const sourcePath = resolve(path);
+  const validation = validateSourceDirectoryResult(sourcePath);
+
+  if (!validation.isValid) {
+    return {
+      path,
+      isValid: false,
+      suggestedName: null,
+      error: validation.error ?? null,
+    };
+  }
+
+  const suggestedName =
+    basename(sourcePath)
+      .toLowerCase()
+      .replace(/[^a-z0-9-]/g, '-')
+      .replace(/-{2,}/g, '-')
+      .replace(/^-+|-+$/g, '') || 'untitled';
+
+  return {
+    path,
+    isValid: true,
+    suggestedName,
+    error: null,
+  };
+}
+
+export function validatePaths(paths: string[]): PathValidationResult[] {
+  return paths.map(validatePath);
+}