@liascript/exporter 2.6.44--0.17.7 → 2.6.44--0.17.8

package/action/src/utils.ts

@@ -1,314 +0,0 @@
-import * as path from 'path';
-import * as fs from 'fs';
-import * as core from '@actions/core';
-import { LiaScriptExporterArgs } from './inputs';
-
-/**
- * Check if a string is a URL
- */
-export function isURL(input: string): boolean {
-  try {
-    new URL(input);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Resolve file paths and set up the working directory structure
- */
-export function resolvePaths(args: LiaScriptExporterArgs): LiaScriptExporterArgs {
-  const resolvedArgs = { ...args };
-  
-  // Convert input file to absolute path
-  if (!path.isAbsolute(args.input) && !isURL(args.input)) {
-    resolvedArgs.input = path.resolve(process.cwd(), args.input);
-  }
-  
-  // Set course path if not provided
-  if (!args.path && !isURL(args.input)) {
-    resolvedArgs.path = path.dirname(resolvedArgs.input);
-  } else if (args.path && !path.isAbsolute(args.path)) {
-    resolvedArgs.path = path.resolve(process.cwd(), args.path);
-  }
-  
-  // Set readme path relative to course path
-  if (resolvedArgs.path && !isURL(resolvedArgs.input)) {
-    resolvedArgs.readme = path.relative(resolvedArgs.path, resolvedArgs.input);
-    if (resolvedArgs.readme.startsWith('../')) {
-      // If input file is outside course path, use the full path
-      resolvedArgs.readme = resolvedArgs.input;
-    } else {
-      resolvedArgs.readme = './' + resolvedArgs.readme;
-    }
-  }
-  
-  return resolvedArgs;
-}
-
-/**
- * Validate that required files exist
- */
-export function validateFiles(args: LiaScriptExporterArgs): void {
-  if (!isURL(args.input)) {
-    if (!fs.existsSync(args.input)) {
-      throw new Error(`Input file does not exist: ${args.input}`);
-    }
-    
-    const stat = fs.statSync(args.input);
-    if (!stat.isFile()) {
-      throw new Error(`Input path is not a file: ${args.input}`);
-    }
-  }
-  
-  // Validate course path if provided
-  if (args.path && !fs.existsSync(args.path)) {
-    throw new Error(`Course path does not exist: ${args.path}`);
-  }
-  
-  // Validate PDF stylesheet if provided
-  if (args['pdf-stylesheet']) {
-    const stylesheetPath = path.isAbsolute(args['pdf-stylesheet'])
-      ? args['pdf-stylesheet']
-      : path.resolve(args.path || path.dirname(args.input), args['pdf-stylesheet']);
-      
-    if (!fs.existsSync(stylesheetPath)) {
-      throw new Error(`PDF stylesheet does not exist: ${stylesheetPath}`);
-    }
-    
-    // Update with resolved path
-    (args as any)['pdf-stylesheet'] = stylesheetPath;
-  }
-}
-
-/**
- * Get file size in bytes
- */
-export function getFileSize(filePath: string): number {
-  try {
-    const stats = fs.statSync(filePath);
-    return stats.size;
-  } catch (error) {
-    core.warning(`Could not get file size for ${filePath}: ${error}`);
-    return 0;
-  }
-}
-
-/**
- * Find output files based on format and output name
- */
-export function findOutputFiles(args: LiaScriptExporterArgs): string[] {
-  // The CLI creates output files in the current working directory
-  const outputDir = process.cwd();
-  const outputName = args.output;
-  const outputFiles: string[] = [];
-  
-  core.info(`Looking for output files in: ${outputDir}`);
-  
-  let expectedFile: string;
-  let description: string;
-  
-  switch (args.format) {
-    case 'scorm1.2':
-      expectedFile = path.join(outputDir, `${outputName}.zip`);
-      description = 'SCORM 1.2';
-      break;
-      
-    case 'scorm2004':
-      expectedFile = path.join(outputDir, `${outputName}.zip`);
-      description = 'SCORM 2004';
-      break;
-      
-    case 'pdf':
-      expectedFile = path.join(outputDir, `${outputName}.pdf`);
-      description = 'PDF';
-      break;
-      
-    case 'web':
-      // Web format can be either a directory or zip file depending on web-zip option
-      if (args['web-zip']) {
-        expectedFile = path.join(outputDir, `${outputName}.zip`);
-        description = 'web ZIP';
-      } else {
-        expectedFile = path.join(outputDir, outputName);
-        description = 'web directory';
-      }
-      break;
-      
-    case 'ims':
-      expectedFile = path.join(outputDir, `${outputName}.zip`);
-      description = 'IMS';
-      break;
-      
-    case 'xapi':
-      expectedFile = path.join(outputDir, `${outputName}.zip`);
-      description = 'xAPI';
-      break;
-      
-    case 'rdf':
-      // RDF format has multiple possible extensions
-      const rdfPatterns = getRdfOutputPatterns(args);
-      for (const pattern of rdfPatterns) {
-        const rdfFile = path.join(outputDir, pattern);
-        if (fs.existsSync(rdfFile)) {
-          outputFiles.push(rdfFile);
-          core.info(`Found RDF file: ${rdfFile}`);
-          return outputFiles;
-        }
-      }
-      core.warning(`No RDF files found with patterns: ${rdfPatterns.join(', ')}`);
-      return outputFiles;
-      
-    case 'project':
-      // Project format can generate multiple files
-      const projectFiles = findProjectOutputFiles(args, outputDir);
-      if (projectFiles.length > 0) {
-        outputFiles.push(...projectFiles);
-        for (const file of projectFiles) {
-          core.info(`Found project file: ${file}`);
-        }
-      } else {
-        core.warning(`No project files found in ${outputDir}`);
-      }
-      return outputFiles;
-      
-    default:
-      expectedFile = path.join(outputDir, `${outputName}.json`);
-      description = 'JSON';
-      break;
-  }
-  
-  // Check for the expected file
-  if (fs.existsSync(expectedFile)) {
-    // For web format, handle both directory and zip cases
-    if (args.format === 'web') {
-      if (args['web-zip']) {
-        // Web ZIP format - expect a file
-        if (fs.statSync(expectedFile).isFile()) {
-          outputFiles.push(expectedFile);
-          core.info(`Found ${description}: ${expectedFile}`);
-        } else {
-          core.warning(`Expected web ZIP file but found directory: ${expectedFile}`);
-        }
-      } else {
-        // Web directory format - expect a directory
-        if (fs.statSync(expectedFile).isDirectory()) {
-          outputFiles.push(expectedFile);
-          core.info(`Found ${description}: ${expectedFile}`);
-        } else {
-          core.warning(`Expected web directory but found file: ${expectedFile}`);
-        }
-      }
-    } else {
-      outputFiles.push(expectedFile);
-      core.info(`Found ${description} file: ${expectedFile}`);
-    }
-  } else {
-    core.warning(`Expected ${description} file not found: ${expectedFile}`);
-    
-    // List what files are actually in the directory for debugging
-    try {
-      const actualFiles = fs.readdirSync(outputDir);
-      core.info(`Files in output directory: ${actualFiles.slice(0, 10).join(', ')}${actualFiles.length > 10 ? '...' : ''}`);
-    } catch (error) {
-      core.warning(`Could not list output directory: ${error}`);
-    }
-  }
-  
-  return outputFiles;
-}
-
-/**
- * Get RDF output patterns based on format setting
- */
-function getRdfOutputPatterns(args: LiaScriptExporterArgs): string[] {
-  const format = args['rdf-format'] || 'json-ld';
-  switch (format) {
-    case 'json-ld':
-      return [`${args.output}.jsonld`, `${args.output}.json`];
-    case 'n-quads':
-      return [`${args.output}.nq`, `${args.output}.txt`];
-    default:
-      return [`${args.output}.json`, `${args.output}.jsonld`, `${args.output}.nq`];
-  }
-}
-
-/**
- * Find project format output files (complex logic for project exports)
- */
-function findProjectOutputFiles(args: LiaScriptExporterArgs, baseDir: string): string[] {
-  const projectFiles: string[] = [];
-  
-  // Project format can generate multiple files based on settings
-  const possibleExtensions = ['.zip', '.pdf', '.json', '.jsonld'];
-  const possiblePrefixes = [args.output, 'project', 'course'];
-  
-  for (const prefix of possiblePrefixes) {
-    for (const ext of possibleExtensions) {
-      const file = path.join(baseDir, prefix + ext);
-      if (fs.existsSync(file)) {
-        projectFiles.push(file);
-      }
-    }
-  }
-  
-  // Also look for directories
-  const possibleDirs = [`${args.output}/`, 'project/', 'courses/'];
-  for (const dir of possibleDirs) {
-    const dirPath = path.join(baseDir, dir);
-    if (fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory()) {
-      projectFiles.push(dirPath);
-    }
-  }
-  
-  return projectFiles;
-}
-
-/**
- * Generate output filename based on input file and format if not specified
- */
-export function generateOutputName(args: LiaScriptExporterArgs): string {
-  if (args.output !== 'output') {
-    return args.output; // User specified output name
-  }
-  
-  // Generate from input file
-  let baseName: string;
-  
-  if (isURL(args.input)) {
-    baseName = 'course'; // Simple fallback for URLs
-  } else {
-    // Extract from file path
-    baseName = path.basename(args.input, path.extname(args.input));
-    if (baseName.toLowerCase() === 'readme') {
-      // Use parent directory name for README files
-      baseName = path.basename(path.dirname(args.input));
-    }
-  }
-  
-  // Basic sanitization
-  baseName = baseName.replace(/[^a-zA-Z0-9-_]/g, '-').replace(/-+/g, '-');
-  
-  return baseName || 'course';
-}
-
-/**
- * Log system information for debugging
- */
-export function logEnvironmentInfo(): void {
-  core.info(`Node.js version: ${process.version}`);
-  core.info(`Platform: ${process.platform}`);
-  core.info(`Architecture: ${process.arch}`);
-  core.info(`Working directory: ${process.cwd()}`);
-}
-
-/**
- * Ensure output directory exists
- */
-export function ensureOutputDirectory(): void {
-  const outputDir = process.cwd();
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
-}

package/action/tsconfig.json

@@ -1,32 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "moduleResolution": "node",
-    "allowSyntheticDefaultImports": true,
-    "resolveJsonModule": true,
-    "noImplicitAny": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noUncheckedIndexedAccess": false
-  },
-  "include": [
-    "src/**/*"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist",
-    "**/*.test.ts",
-    "**/*.spec.ts"
-  ]
-}