@liascript/exporter 3.0.0--1.0.3 → 3.0.1--1.0.3

package/src/export/helper.ts

@@ -1,360 +0,0 @@
-'use strict'
-
-import fetch from 'node-fetch'
-import * as temp from 'temp'
-import * as fs from 'fs-extra'
-import * as path from 'path'
-const archiver = require('archiver')
-const beautify = require('simply-beautiful')
-
-// Constants
-const TEMP_DIR_PREFIX = 'lia'
-const DIST_DIR_RELATIVE_PATH = '../../dist'
-const ZIP_COMPRESSION_LEVEL = 9
-const RANDOM_STRING_LENGTH = 16
-const RANDOM_CHARS =
-  'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-const BEAUTIFY_OPTIONS = {
-  indent_size: 4,
-  space_before_conditional: true,
-  jslint_happy: true,
-  max_char: 0,
-}
-
-/**
- * Creates a temporary directory with a unique name.
- * @returns Promise that resolves to the path of the created temporary directory
- */
-export function tmpDir(): Promise<string> {
-  return new Promise((resolve, reject) => {
-    temp.mkdir(TEMP_DIR_PREFIX, function (err: Error | null, tmpPath: string) {
-      if (err) reject(err)
-      else resolve(tmpPath)
-    })
-  })
-}
-
-/**
- * Returns the absolute path to the distribution directory.
- * @returns The path to the dist directory (where index.js is located)
- */
-export function dirname(): string {
-  // Get the directory where the main entry point (index.js) is located
-  // This works both in Docker and locally because it's relative to the actual running file
-  const mainFile = require.main?.filename || process.argv[1]
-
-  return path.dirname(mainFile)
-}
-
-/**
- * Delays execution for a specified number of milliseconds.
- * @param ms - Number of milliseconds to sleep
- * @returns Promise that resolves after the specified delay
- */
-export function sleep(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms))
-}
-
-/**
- * Writes content to a file.
- * @param filename - Path to the file to write
- * @param content - Content to write to the file
- * @returns Promise that resolves when the file is written
- */
-export function writeFile(filename: string, content: string): Promise<string> {
-  return new Promise((resolve, reject) => {
-    fs.writeFile(filename, content, function (err: Error | null) {
-      if (err) reject(err)
-      else resolve('ok')
-    })
-  })
-}
-
-/**
- * Creates a filter function to exclude hidden folders and node_modules during copy operations.
- * @param sourceDir - The source directory being copied
- * @returns A filter function that returns false for hidden folders and node_modules
- */
-export function filterHidden(
-  sourceDir: string,
-): (src: string, dest: string) => boolean {
-  return function (src: string, dest: string): boolean {
-    // Get the relative path of the source folder being copied
-    const relPath = path.relative(path.resolve(sourceDir), src)
-
-    // Split the relative path into its components
-    const components = relPath.split(path.sep)
-
-    // Check each component for hidden folders
-    for (const component of components) {
-      // Check if the component starts with a dot (i.e., hidden folder)
-      if (component.startsWith('.')) {
-        return false // Exclude the folder from the copy
-      }
-
-      // Check if the current folder being copied is the "node_modules" folder
-      if (component === 'node_modules') {
-        return false // Exclude the folder from the copy
-      }
-    }
-
-    return true // Include the folder in the copy
-  }
-}
-
-/**
- * Injects ResponsiveVoice script tag into an HTML string.
- * @param key - ResponsiveVoice API key
- * @param into - HTML content to inject the script into
- * @returns Modified HTML content with the ResponsiveVoice script
- */
-export function injectResponsivevoice(key: string, into: string): string {
-  return inject(
-    `<script src="https://code.responsivevoice.org/responsivevoice.js?key=${key}"></script>`,
-    into,
-  )
-}
-
-/**
- * Inject an arbitrary tag into HTML content.
- * @param element - new tag to be added
- * @param into - old index.html content
- * @param tag - Tag to inject at. Can be:
- *   - boolean: true for after `<head>`, false for before `</head>` (backward compatibility)
- *   - string: opening tag like `<body>` (injects after) or closing tag like `</body>` (injects before)
- * @returns - new index.html content
- */
-export function inject(
-  element: string,
-  into: string,
-  tag: string | boolean = false,
-): string {
-  // Backward compatibility: handle boolean parameter
-  if (typeof tag === 'boolean') {
-    return tag
-      ? into.replace('<head>', '<head>' + element)
-      : into.replace('</head>', element + '</head>')
-  }
-
-  // New string-based tag injection
-  if (tag.startsWith('</')) {
-    // Closing tag: inject before it
-    return into.replace(tag, element + tag)
-  } else {
-    // Opening tag: inject after it
-    return into.replace(tag, tag + element)
-  }
-}
-
-/**
- * Checks if a string is a valid URL (http, https, or file protocol).
- * @param uri - The string to check
- * @returns True if the string is a URL, false otherwise
- */
-export function isURL(uri: string): boolean {
-  return (
-    uri.startsWith('http://') ||
-    uri.startsWith('https://') ||
-    uri.startsWith('file://')
-  )
-}
-
-/**
- * Creates an HTML iframe wrapper file for embedding LiaScript content.
- * @param tmpPath - Path to the temporary directory
- * @param filename - Name of the file to create
- * @param readme - Path to the README file
- * @param jsonLD - JSON-LD metadata to inject
- * @param style - Optional custom CSS styles for the iframe
- * @param index - Optional custom index.html filename
- * @returns Promise that resolves when the file is written
- */
-export async function iframe(
-  tmpPath: string,
-  filename: string,
-  readme: string,
-  jsonLD: string,
-  style?: string,
-  index?: string,
-): Promise<string> {
-  await writeFile(
-    path.join(tmpPath, filename),
-    prettify(`<!DOCTYPE html>
-    <html style="height:100%; overflow: hidden">
-    <head>
-      ${jsonLD}
-    </head>
-    <body style="height:100%; margin: 0px">
-    
-    <iframe id="lia-container" src="" style="${
-      style || 'border: 0px; width: 100%; height: 100%'
-    }"></iframe>
-    
-    <script>
-      let path = window.location.pathname.replace("start.html", "")
-      let iframe = document.getElementById("lia-container")
-
-      if (iframe) {          
-        const src = path + "${
-          index || 'index.html'
-        }?" + path + "${readme.replace('./', '')}"
-        iframe.src = src 
-      }
-    </script>
-
-    </body>
-    </html> 
-    `),
-  )
-
-  return 'ok'
-}
-
-/**
- * Creates a ZIP archive from a directory.
- * @param dir - Directory to archive
- * @param filename - Base filename for the ZIP archive (without .zip extension)
- * @returns Promise that resolves when the archive is finalized
- */
-export async function zip(dir: string, filename: string): Promise<void> {
-  return new Promise((resolve, reject) => {
-    const output = fs.createWriteStream(
-      path.dirname(filename) + '/' + path.basename(filename + '.zip'),
-    )
-
-    const archive = archiver('zip', {
-      zlib: { level: ZIP_COMPRESSION_LEVEL }, // Sets the compression level.
-    })
-
-    // listen for all archive data to be written
-    // 'close' event is fired only when a file descriptor is involved
-    output.on('close', function () {
-      console.log(archive.pointer() + ' total bytes')
-      console.log(
-        'archiver has been finalized and the output file descriptor has closed.',
-      )
-      resolve()
-    })
-
-    // This event is fired when the data source is drained no matter what was the data source.
-    // It is not part of this library but rather from the NodeJS Stream API.
-    // @see: https://nodejs.org/api/stream.html#stream_event_end
-    output.on('end', function () {
-      console.log('Data has been drained')
-    })
-
-    // good practice to catch warnings (ie stat failures and other non-blocking errors)
-    archive.on('warning', function (err: any) {
-      if (err.code === 'ENOENT') {
-        console.warn('Archive warning:', err)
-      } else {
-        reject(err)
-      }
-    })
-
-    // good practice to catch this error explicitly
-    archive.on('error', function (err: Error) {
-      reject(err)
-    })
-
-    // pipe archive data to the file
-    archive.pipe(output)
-
-    archive.directory(dir, false)
-    archive.finalize()
-  })
-}
-
-/**
- * Generates a random alphanumeric string.
- * Note: Uses Math.random() - not cryptographically secure.
- * @param length - Length of the random string to generate (default: 16)
- * @returns Random alphanumeric string
- */
-export function random(length: number = RANDOM_STRING_LENGTH): string {
-  // Pick characters randomly
-  let str = ''
-  for (let i = 0; i < length; i++) {
-    str += RANDOM_CHARS.charAt(Math.floor(Math.random() * RANDOM_CHARS.length))
-  }
-
-  return str
-}
-
-/**
- * Parses a raw GitHub URL and extracts repository information.
- * Supports URLs in format: raw.githubusercontent.com/org/repo/branch/path or raw.githubusercontent.com/org/repo/refs/heads/branch/path
- * @param raw_url - Raw GitHub URL to parse
- * @returns Object with repository information or null if URL doesn't match
- */
-export function getRepository(raw_url: string): {
-  url: string
-  branch: string
-  path: string
-  cmd: string
-} | null {
-  const match = raw_url.match(
-    /raw\.githubusercontent\.com\/([^\/]+)\/([^\/]+)\/(?:refs\/heads\/)?([^\/]+)\/(.*)/i,
-  )
-
-  if (match?.length === 5) {
-    const [_, organization, repository, branch, filePath] = match
-
-    const url = `https://github.com/${organization}/${repository}`
-
-    return {
-      url,
-      branch,
-      path: filePath,
-      cmd: `git clone --branch ${branch} ${url} tmp`,
-    }
-  }
-
-  return null
-}
-
-/**
- * Checks if a LICENSE file exists at the given base URL.
- * @param baseURL - Base URL to check for LICENSE file
- * @returns Promise that resolves to true if LICENSE exists, false otherwise
- */
-export async function checkLicense(baseURL: string): Promise<boolean> {
-  const url = new URL('LICENSE', baseURL).href
-
-  return await checkFileExists(url)
-}
-
-/**
- * Extracts the base URL by removing the last path segment.
- * @param url - URL to extract base from
- * @returns Base URL without the last path segment
- */
-export function baseURL(url: string): string {
-  const pathSegments = url.split('/')
-  pathSegments.pop()
-  return pathSegments.join('/')
-}
-
-/**
- * Checks if a file exists at the given URL using a HEAD request.
- * @param fileUrl - URL of the file to check
- * @returns Promise that resolves to true if file exists (200 status), false otherwise
- */
-async function checkFileExists(fileUrl: string): Promise<boolean> {
-  try {
-    const response = await fetch(fileUrl, { method: 'HEAD' })
-    return response.status === 200
-  } catch (error) {
-    console.warn(`Error checking if file exists: ${error}`)
-    return false
-  }
-}
-
-/**
- * Prettifies HTML content using beautification options.
- * @param html - HTML string to prettify
- * @returns Prettified HTML string
- */
-export function prettify(html: string): string {
-  return beautify.html(html, BEAUTIFY_OPTIONS)
-}

package/src/export/ims.ts

@@ -1,191 +0,0 @@
-import * as helper from './helper'
-import * as RDF from './rdf'
-import * as COLOR from '../colorize'
-
-const path = require('path')
-const fs = require('fs-extra')
-
-export function help() {
-  console.log('')
-  console.log(COLOR.heading('IMS settings:'), '\n')
-
-  COLOR.info(
-    'IMS (Instructional Management Systems) Content Package is an interoperable standard format for packaging learning content between different LMSes.',
-  )
-  console.log(
-    '\nLearn more: https://www.imsglobal.org/content/packaging/index.html\n',
-  )
-
-  COLOR.command(
-    null,
-    '--ims-indexeddb',
-    '           Use IndexedDB to store data persistently',
-  )
-
-  console.log('')
-  console.log(COLOR.heading('WEB settings:'), '\n')
-
-  COLOR.info(
-    'Pack the project into a self contained web project that can be hosted everywhere.',
-  )
-
-  console.log('')
-
-  COLOR.command(
-    null,
-    '--web-iframe',
-    '              Use an iframed version to hide the course URL.',
-  )
-  COLOR.command(
-    null,
-    '--web-indexeddb',
-    '           This will allow to store data within the browser using indexeddb, you can optionally pass a unique key (by default one is generated randomly).',
-  )
-  COLOR.command(
-    null,
-    '--web-zip',
-    '                 By default the result is not zipped, you can change this with this parameter.',
-  )
-}
-
-export interface ImsExportArguments {
-  input: string
-  readme: string
-  output: string
-  format: string
-  path: string
-  key?: string
-  style?: string
-  'ims-indexeddb'?: boolean
-}
-
-export const format = 'ims'
-
-export async function exporter(argument: ImsExportArguments, json: any) {
-  if (typeof json === 'string') {
-    json = JSON.parse(json)
-  }
-
-  const dirname = helper.dirname()
-
-  // make temp folder
-  let tmp = await helper.tmpDir()
-
-  let tmpPath = path.join(tmp, 'pro')
-
-  // copy assets to temp
-  await fs.copy(
-    path.join(
-      dirname,
-      argument['ims-indexeddb'] ? './assets/indexeddb' : './assets/web',
-    ),
-    tmpPath,
-  )
-  await fs.copy(path.join(dirname, './assets/common'), tmpPath)
-
-  let index = fs.readFileSync(path.join(tmpPath, 'index.html'), 'utf8')
-
-  // change responsive key
-  if (argument.key) {
-    index = helper.injectResponsivevoice(argument.key, index)
-  }
-
-  try {
-    await helper.writeFile(path.join(tmpPath, 'index.html'), index)
-  } catch (e) {
-    console.warn(e)
-    return
-  }
-
-  await manifest(tmpPath, json.lia)
-
-  // copy base path or readme-directory into temp
-  await fs.copy(argument.path, tmpPath, {
-    filter: helper.filterHidden(argument.path),
-  })
-
-  if (argument['ims-indexeddb']) {
-    let newReadme = helper.random(20) + '.md'
-
-    let old_ = path.join(tmpPath, argument.readme)
-    let new_ = path.join(path.dirname(old_), newReadme)
-
-    argument.readme = argument.readme.replace(
-      path.basename(argument.readme),
-      newReadme,
-    )
-
-    await fs.move(old_, new_)
-  }
-
-  const jsonLD = await RDF.script(argument, json)
-
-  await helper.iframe(
-    tmpPath,
-    'start.html',
-    argument.readme,
-    jsonLD,
-    argument.style,
-  )
-
-  await helper.zip(tmpPath, argument.output)
-}
-
-async function manifest(tmpPath: any, meta: any) {
-  let keywords = ''
-
-  try {
-    const tags = meta.definition.macro.tags
-      .split(',')
-      .map((e: string) => e.trim())
-
-    for (let i = 0; i < tags.length; i++) {
-      keywords += `<imsmd:langstring xml:lang="${meta.definition.language}">${tags[i]}</imsmd:langstring>`
-    }
-  } catch (e) {}
-
-  await helper.writeFile(
-    path.join(tmpPath, 'imsmanifest.xml'),
-    `<manifest xmlns="http://www.imsglobal.org/xsd/imscp_v1p1" xmlns:imsmd="http://www.imsglobal.org/xsd/imsmd_v1p2"
-    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-    xsi:schemaLocation="http://www.imsglobal.org/xsd/imscp_v1p1 http://www.imsglobal.org/xsd/imscp_v1p1.xsd http://www.imsglobal.org/xsd/imsmd_v1p2 http://www.imsglobal.org/xsd/imsmd_v1p2.xsd "
-    identifier="Manifest5-CEC3D3-3201-DF8E-8F42-3CEED12F4197" version="IMS CP 1.1.4">
-    <metadata>
-        <schema>IMS Content</schema>
-        <schemaversion>1.1.4</schemaversion>
-        <imsmd:lom>
-            <imsmd:general>
-                <imsmd:title>
-                    <imsmd:langstring xml:lang="${meta.definition.language}">${meta.str_title}</imsmd:langstring>
-                </imsmd:title>
-                <imsmd:language>${meta.definition.language}</imsmd:language>
-                <imsmd:description>
-                    <imsmd:langstring xml:lang="${meta.definition.language}">${meta.comment}</imsmd:langstring>
-                </imsmd:description>
-                <imsmd:keyword>
-                    ${keywords}
-                </imsmd:keyword>
-            </imsmd:general>
-            <imsmd:lifecycle>
-                <imsmd:version>
-                    <imsmd:langstring xml:lang="${meta.definition.language}">${meta.definition.version}</imsmd:langstring>
-                </imsmd:version>
-            </imsmd:lifecycle>
-        </imsmd:lom>
-    </metadata>
-    <organizations default="TOC1">
-        <organization identifier="TOC1" structure="hierarchical">
-            <title>All Lessons</title>
-            <item identifier="ITEM1" identifierref="LIASCRIPT">
-                <title>LiaScript - Course</title>
-            </item>
-        </organization>
-    </organizations>
-    <resources>
-        <resource identifier="LIASCRIPT" type="webcontent" href="start.html">
-            <file href="start.html" />
-        </resource>
-    </resources>
-</manifest>`,
-  )
-}