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

package/action/dist/inputs.js

@@ -1,173 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logInputs = exports.validateInputs = exports.parseInputs = void 0;
-const core = __importStar(require("@actions/core"));
-/**
- * Helper function to safely get boolean inputs, handling empty/undefined values
- */
-function getBooleanInput(name, defaultValue = false) {
-    const input = core.getInput(name);
-    return input ? core.getBooleanInput(name) : defaultValue;
-}
-/**
- * Parse and validate GitHub Action inputs into LiaScript Exporter arguments
- */
-function parseInputs() {
-    // Core required inputs
-    const inputFile = core.getInput('input-file', { required: true });
-    const format = core.getInput('format', { required: true });
-    // Optional core inputs
-    const outputName = core.getInput('output-name') || 'output';
-    const coursePath = core.getInput('course-path');
-    // Validate format
-    const validFormats = [
-        'scorm1.2', 'scorm2004', 'pdf', 'web', 'ims', 'xapi', 'rdf', 'json', 'project'
-    ];
-    if (!validFormats.includes(format.toLowerCase())) {
-        throw new Error(`Invalid format '${format}'. Valid formats: ${validFormats.join(', ')}`);
-    }
-    // Build the arguments object
-    const args = {
-        input: inputFile,
-        readme: inputFile,
-        output: outputName,
-        format: format.toLowerCase(),
-        path: coursePath,
-        key: core.getInput('responsive-voice-key') || undefined,
-        style: core.getInput('style') || undefined,
-        // SCORM settings
-        'scorm-organization': core.getInput('scorm-organization') || undefined,
-        'scorm-masteryScore': core.getInput('scorm-mastery-score') || undefined,
-        'scorm-typicalDuration': core.getInput('scorm-typical-duration') || 'PT0H5M0S',
-        'scorm-iframe': getBooleanInput('scorm-iframe'),
-        'scorm-embed': getBooleanInput('scorm-embed'),
-        'scorm-alwaysActive': getBooleanInput('scorm-always-active'),
-        // IMS settings
-        'ims-indexeddb': getBooleanInput('ims-indexeddb'),
-        // Web settings
-        'web-zip': getBooleanInput('web-zip', true),
-        'web-indexeddb': getBooleanInput('web-indexeddb'),
-        'web-iframe': getBooleanInput('web-iframe'),
-        // PDF settings
-        'pdf-scale': core.getInput('pdf-scale') || '1',
-        'pdf-printBackground': getBooleanInput('pdf-print-background'),
-        'pdf-landscape': getBooleanInput('pdf-landscape'),
-        'pdf-format': core.getInput('pdf-format') || 'A4',
-        'pdf-stylesheet': core.getInput('pdf-stylesheet') || undefined,
-        'pdf-theme': core.getInput('pdf-theme') || 'default',
-        // RDF settings
-        'rdf-format': core.getInput('rdf-format') || 'json-ld',
-        'rdf-url': core.getInput('rdf-url') || undefined,
-        'rdf-type': core.getInput('rdf-type') || 'Course',
-        'rdf-license': core.getInput('rdf-license') || undefined,
-        'rdf-educationalLevel': core.getInput('rdf-educational-level') || undefined,
-        // xAPI settings
-        'xapi-endpoint': core.getInput('xapi-endpoint') || undefined,
-        'xapi-auth': core.getInput('xapi-auth') || undefined,
-        'xapi-actor': core.getInput('xapi-actor') || undefined,
-        'xapi-course-id': core.getInput('xapi-course-id') || undefined,
-        'xapi-course-title': core.getInput('xapi-course-title') || undefined,
-        'xapi-debug': getBooleanInput('xapi-debug'),
-        'xapi-zip': getBooleanInput('xapi-zip'),
-    };
-    return args;
-}
-exports.parseInputs = parseInputs;
-/**
- * Validate required inputs based on format
- */
-function validateInputs(args) {
-    // Format-specific validations
-    switch (args.format) {
-        case 'xapi':
-            if (args['xapi-endpoint'] && !isValidUrl(args['xapi-endpoint'])) {
-                throw new Error('xapi-endpoint must be a valid URL');
-            }
-            break;
-        case 'rdf':
-            if (args['rdf-url'] && !isValidUrl(args['rdf-url'])) {
-                throw new Error('rdf-url must be a valid URL');
-            }
-            if (args['rdf-license'] && !isValidUrl(args['rdf-license'])) {
-                throw new Error('rdf-license must be a valid URL');
-            }
-            break;
-        case 'pdf':
-            if (args['pdf-scale']) {
-                const scale = parseFloat(args['pdf-scale']);
-                if (isNaN(scale) || scale <= 0 || scale > 2) {
-                    throw new Error('pdf-scale must be a number between 0 and 2');
-                }
-            }
-            break;
-        case 'scorm1.2':
-        case 'scorm2004':
-            if (args['scorm-masteryScore']) {
-                const score = parseInt(args['scorm-masteryScore'], 10);
-                if (isNaN(score) || score < 0 || score > 100) {
-                    throw new Error('scorm-mastery-score must be a number between 0 and 100');
-                }
-            }
-            break;
-    }
-}
-exports.validateInputs = validateInputs;
-/**
- * Helper function to validate URLs
- */
-function isValidUrl(url) {
-    try {
-        new URL(url);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Log the parsed inputs for debugging
- */
-function logInputs(args) {
-    core.info(`input: ${args.input}`);
-    core.info(`format: ${args.format}`);
-    core.info(`output: ${args.output}`);
-    if (args.path)
-        core.info(`path: ${args.path}`);
-    // Log non-default settings
-    Object.entries(args).forEach(([key, value]) => {
-        if (key.includes('-') && value !== undefined && value !== false && value !== '') {
-            // Simple masking for sensitive fields
-            if (key.includes('key') || key.includes('auth')) {
-                core.info(`${key}: ***`);
-            }
-            else {
-                core.info(`${key}: ${value}`);
-            }
-        }
-    });
-}
-exports.logInputs = logInputs;
-//# sourceMappingURL=inputs.js.map

package/action/dist/utils.js

@@ -1,320 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ensureOutputDirectory = exports.logEnvironmentInfo = exports.generateOutputName = exports.findOutputFiles = exports.getFileSize = exports.validateFiles = exports.resolvePaths = exports.isURL = void 0;
-const path = __importStar(require("path"));
-const fs = __importStar(require("fs"));
-const core = __importStar(require("@actions/core"));
-/**
- * Check if a string is a URL
- */
-function isURL(input) {
-    try {
-        new URL(input);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-exports.isURL = isURL;
-/**
- * Resolve file paths and set up the working directory structure
- */
-function resolvePaths(args) {
-    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;
-}
-exports.resolvePaths = resolvePaths;
-/**
- * Validate that required files exist
- */
-function validateFiles(args) {
-    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['pdf-stylesheet'] = stylesheetPath;
-    }
-}
-exports.validateFiles = validateFiles;
-/**
- * Get file size in bytes
- */
-function getFileSize(filePath) {
-    try {
-        const stats = fs.statSync(filePath);
-        return stats.size;
-    }
-    catch (error) {
-        core.warning(`Could not get file size for ${filePath}: ${error}`);
-        return 0;
-    }
-}
-exports.getFileSize = getFileSize;
-/**
- * Find output files based on format and output name
- */
-function findOutputFiles(args) {
-    // The CLI creates output files in the current working directory
-    const outputDir = process.cwd();
-    const outputName = args.output;
-    const outputFiles = [];
-    core.info(`Looking for output files in: ${outputDir}`);
-    let expectedFile;
-    let description;
-    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;
-}
-exports.findOutputFiles = findOutputFiles;
-/**
- * Get RDF output patterns based on format setting
- */
-function getRdfOutputPatterns(args) {
-    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, baseDir) {
-    const projectFiles = [];
-    // 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
- */
-function generateOutputName(args) {
-    if (args.output !== 'output') {
-        return args.output; // User specified output name
-    }
-    // Generate from input file
-    let baseName;
-    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';
-}
-exports.generateOutputName = generateOutputName;
-/**
- * Log system information for debugging
- */
-function logEnvironmentInfo() {
-    core.info(`Node.js version: ${process.version}`);
-    core.info(`Platform: ${process.platform}`);
-    core.info(`Architecture: ${process.arch}`);
-    core.info(`Working directory: ${process.cwd()}`);
-}
-exports.logEnvironmentInfo = logEnvironmentInfo;
-/**
- * Ensure output directory exists
- */
-function ensureOutputDirectory() {
-    const outputDir = process.cwd();
-    if (!fs.existsSync(outputDir)) {
-        fs.mkdirSync(outputDir, { recursive: true });
-    }
-}
-exports.ensureOutputDirectory = ensureOutputDirectory;
-//# sourceMappingURL=utils.js.map

package/action/examples/matrix-build.yml

@@ -1,64 +0,0 @@
-name: Release Course Packages
-on:
-  push:
-    tags:
-      - 'v*'
-
-jobs:
-  build-and-release:
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Extract tag name
-      run: echo "TAG_NAME=${GITHUB_REF#refs/tags/}" >> $GITHUB_ENV
-    
-    - name: Export to SCORM 1.2
-      id: export-scorm
-      uses: LiaScript/LiaScript-Exporter@master
-      with:
-        input-file: 'README.md'
-        format: 'scorm1.2'
-        output-name: 'course-${{ env.TAG_NAME }}-scorm1.2'
-        scorm-organization: 'My Organization'
-        scorm-mastery-score: '80'
-    
-    - name: Export to PDF
-      id: export-pdf
-      uses: LiaScript/LiaScript-Exporter@master
-      with:
-        input-file: 'README.md'
-        format: 'pdf'
-        output-name: 'course-${{ env.TAG_NAME }}'
-        pdf-format: 'A4'
-        pdf-landscape: false
-    
-    - name: Export to Web
-      id: export-web
-      uses: LiaScript/LiaScript-Exporter@master
-      with:
-        input-file: 'README.md'
-        format: 'web'
-        output-name: 'course-${{ env.TAG_NAME }}-web'
-        web-zip: true
-        web-indexeddb: true
-    
-    - name: Create Release
-      uses: softprops/action-gh-release@v1
-      with:
-        files: |
-          ${{ steps.export-scorm.outputs.output-file }}
-          ${{ steps.export-pdf.outputs.output-file }}
-          ${{ steps.export-web.outputs.output-file }}
-        body: |
-          Course packages for ${{ env.TAG_NAME }}
-          
-          - SCORM 1.2 package for LMS deployment
-          - PDF version for offline reading
-          - Web package for standalone hosting
-        draft: false
-        prerelease: false
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

package/action/examples/multi-course.yml

@@ -1,39 +0,0 @@
-name: Multi-Course Export
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  export:
-    runs-on: ubuntu-latest
-    
-    strategy:
-      matrix:
-        course: 
-          - { path: 'course1/README.md', name: 'basic-course' }
-          - { path: 'course2/README.md', name: 'advanced-course' }
-          - { path: 'course3/README.md', name: 'expert-course' }
-        format: ['scorm1.2', 'pdf', 'web']
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Export ${{ matrix.course.name }} to ${{ matrix.format }}
-      id: export
-      uses: LiaScript/LiaScript-Exporter@master
-      with:
-        input-file: ${{ matrix.course.path }}
-        format: ${{ matrix.format }}
-        output-name: '${{ matrix.course.name }}-${{ matrix.format }}'
-        scorm-organization: 'LiaScript Courses'
-        pdf-theme: 'default'
-        web-zip: true
-    
-    - name: Upload ${{ matrix.course.name }}-${{ matrix.format }}
-      uses: actions/upload-artifact@v4
-      with:
-        name: ${{ matrix.course.name }}-${{ matrix.format }}
-        path: ${{ steps.export.outputs.output-file }}

package/action/examples/single-course.yml

@@ -1,42 +0,0 @@
-name: Export Single Course
-on:
-  workflow_dispatch:
-    inputs:
-      format:
-        description: 'Export format'
-        required: true
-        default: 'scorm1.2'
-        type: choice
-        options:
-        - scorm1.2
-        - scorm2004
-        - pdf
-        - web
-        - ims
-        - xapi
-        - rdf
-
-jobs:
-  export:
-    runs-on: ubuntu-latest
-    
-    steps:
-    - name: Checkout repository
-      uses: actions/checkout@v4
-    
-    - name: Export course to ${{ inputs.format }}
-      id: export
-      uses: LiaScript/LiaScript-Exporter@master
-      with:
-        input-file: 'README.md'
-        format: ${{ inputs.format }}
-        output-name: 'my-course'
-        scorm-organization: 'My Organization'
-        pdf-format: 'A4'
-        web-zip: true
-    
-    - name: Upload exported course
-      uses: actions/upload-artifact@v4
-      with:
-        name: course-${{ inputs.format }}
-        path: ${{ steps.export.outputs.output-file }}