feat(ghoulscript): add option to disable cdn

Author: adenvt

package.json

@@ -3,7 +3,8 @@
   "packageManager": "yarn@4.2.2",
   "private": true,
   "workspaces": [
-    "packages/*"
+    "packages/*",
+    "playground/*"
   ],
   "scripts": {
     "lint": "eslint . --ext .js,.vue,.ts --format pretty",

packages/ghoulscript/build.config.ts

@@ -1,7 +1,20 @@
 import { defineBuildConfig } from 'unbuild'
 
 export default defineBuildConfig({
-  entries    : ['src/index', 'src/rpc.worker'],
+  entries: [
+    {
+      input : 'src/',
+      outDir: 'dist/',
+      format: 'esm',
+    },
+    {
+      input      : 'src/',
+      outDir     : 'dist/',
+      format     : 'cjs',
+      ext        : 'cjs',
+      declaration: false,
+    },
+  ],
   declaration: true,
   rollup     : { emitCJS: true },
 })

packages/ghoulscript/package.json

@@ -1,19 +1,16 @@
 {
   "name": "@privyid/ghoulscript",
   "packageManager": "yarn@4.2.2",
+  "version": "0.1.0-alpha.1",
   "type": "module",
   "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.mjs",
       "require": "./dist/index.cjs",
       "types": "./dist/index.d.ts"
-    },
-    "./rpc.worker": {
-      "import": "./dist/rpc.worker.mjs",
-      "require": "./dist/rpc.worker.cjs",
-      "types": "./dist/rpc.worker.d.ts"
     }
   },
   "files": [
@@ -25,14 +22,14 @@
     "test": "jiti ./tests/sample.ts"
   },
   "devDependencies": {
-    "@tsconfig/node20": "^20.1.4",
     "jiti": "^1.21.0",
     "typescript": "^5.4.5",
-    "unbuild": "^2.0.0"
+    "unbuild": "3.0.0-rc.6"
   },
   "dependencies": {
     "@privyid/ghostscript": "workspace:^",
-    "defu": "^6.1.4"
+    "defu": "^6.1.4",
+    "ufo": "^1.5.3"
   },
   "license": "AGPL-3.0-only"
 }

packages/ghoulscript/src/config.ts

@@ -0,0 +1,44 @@
+import { defu } from 'defu'
+import { withBase } from 'ufo'
+import meta from '@privyid/ghostscript/meta'
+import { name, version } from '../package.json'
+
+export interface Config {
+  /**
+   * Enable worker
+   * @default true
+   */
+  useWorker: boolean,
+  /**
+   * Enable CDN
+   * @default true
+   */
+  useCDN: boolean,
+  /**
+   * CDN BaseURL
+   * @default 'https://unpkg.com/'
+   */
+  cdnURL: string,
+}
+
+let config: Config = {
+  useWorker: typeof window !== 'undefined',
+  useCDN   : true,
+  cdnURL   : 'https://unpkg.com/',
+}
+
+export function useConfig () {
+  return config
+}
+
+export function configureGS (config_: Partial<Config>) {
+  config = defu(config_, config)
+}
+
+export function getWorkerURL () {
+  return withBase(`${name as string}@${version as string}/dist/rpc.worker.mjs`, config.cdnURL)
+}
+
+export function getFileURL (url: string) {
+  return withBase(`${meta.name}@${meta.version}/dist/${url}`, config.cdnURL)
+}

packages/ghoulscript/src/core.ts

@@ -1,5 +1,8 @@
-import useGS from '@privyid/ghostscript'
+import type { GSModule } from '@privyid/ghostscript'
+import initGS from '@privyid/ghostscript'
 import { defu } from 'defu'
+import { getFileURL, useConfig } from './config'
+import { joinRelativeURL } from 'ufo'
 
 interface PageRange {
   start: number,
@@ -63,6 +66,17 @@ export interface CompressOptions {
   pageList?: PageList,
 }
 
+async function useGS (moduleOverrides?: Partial<GSModule>) {
+  return await initGS(defu<Partial<GSModule>, [Partial<GSModule>]>(moduleOverrides, {
+    locateFile (url: string, dir: string) {
+      if ((typeof window !== 'undefined' || typeof importScripts === 'function') && useConfig().useCDN)
+        return getFileURL(url)
+
+      return joinRelativeURL(dir, url)
+    },
+  }))
+}
+
 async function createPDF (inputs: ArrayBufferView[], options: Partial<CompressOptions> = {}): Promise<Uint8Array> {
   const gs   = await useGS()
   const opts = defu<CompressOptions, [CompressOptions]>(options, {
@@ -138,14 +152,33 @@ async function createPDF (inputs: ArrayBufferView[], options: Partial<CompressOp
   return gs.FS.readFile('./output', { encoding: 'binary' })
 }
 
+/**
+ * Optimize PDF and redure file size
+ * @param input
+ * @param option
+ * @returns
+ */
 export async function optimizePDF (input: ArrayBufferView, option: Partial<CompressOptions> = {}) {
   return await createPDF([input], option)
 }
 
+/**
+ * Merge multiple files into single file
+ * @param inputs
+ * @param option
+ * @returns
+ */
 export async function combinePDF (inputs: ArrayBufferView[], option: Partial<CompressOptions> = {}) {
   return await createPDF(inputs, option)
 }
 
+/**
+ * Split PDF into multiple files
+ * @param input
+ * @param pageLists
+ * @param option
+ * @returns
+ */
 export async function splitPdf (input: ArrayBufferView, pageLists: PageList[], option: Partial<CompressOptions> = {}) {
   return await Promise.all(
     pageLists.map(async (pageList) => {
@@ -154,6 +187,13 @@ export async function splitPdf (input: ArrayBufferView, pageLists: PageList[], o
   )
 }
 
+/**
+ * Add encryption password
+ * @param input
+ * @param userPassword
+ * @param ownerPassword
+ * @returns
+ */
 export async function addPassword (input: ArrayBufferView, userPassword: string, ownerPassword: string = userPassword) {
   return await createPDF([input], {
     ownerPassword,
@@ -194,6 +234,13 @@ export interface RenderOptions {
   format: 'jpg' | 'png',
 }
 
+/**
+ * Convert PDF to image
+ * @param input Input buffer
+ * @param pageNumber
+ * @param options
+ * @returns
+ */
 export async function renderPageAsImage (input: ArrayBufferView, pageNumber: number = 1, options: Partial<RenderOptions> = {}) {
   const gs   = await useGS()
   const opts = defu<RenderOptions, [RenderOptions]>(options, {

packages/ghoulscript/src/index.ts

@@ -1,53 +1,53 @@
+import { useConfig } from './config'
 import type {
   CommandArgs,
   CommandResult,
   Commands,
-} from './rpc.js'
+} from './rpc'
 import {
   callRPC,
   callWorkerRPC,
-} from './rpc.js'
+} from './rpc'
+import type * as core from './core'
 
-interface GSConfig {
-  useWebWorker: boolean,
-}
-
-const config: GSConfig = { useWebWorker: typeof window !== 'undefined' }
+export {
+  configureGS,
+} from './config'
 
-export function configureGS (config_: Partial<GSConfig>) {
-  Object.assign(config, config_)
-}
+export {
+  setWorkerRPC,
+} from './rpc'
 
 async function call <C extends Commands> (name: C, args: CommandArgs<C>): Promise<CommandResult<C>> {
-  return config.useWebWorker
-    ? await callWorkerRPC(name, args)
-    : await callRPC(name, args)
+  return useConfig().useWorker
+    ? callWorkerRPC(name, args)
+    : callRPC(name, args)
 }
 
-export async function optimizePDF (...args: CommandArgs<'optimizePDF'>): CommandResult<'optimizePDF'> {
+export const optimizePDF: typeof core.optimizePDF = async (...args: CommandArgs<'optimizePDF'>): CommandResult<'optimizePDF'> => {
   return await call('optimizePDF', args)
 }
 
-export async function combinePDF (...args: CommandArgs<'combinePDF'>): CommandResult<'combinePDF'> {
+export const combinePDF: typeof core.combinePDF = async (...args: CommandArgs<'combinePDF'>): CommandResult<'combinePDF'> => {
   return await call('combinePDF', args)
 }
 
-export async function splitPdf (...args: CommandArgs<'splitPdf'>): CommandResult<'splitPdf'> {
+export const splitPdf: typeof core.splitPdf =  async (...args: CommandArgs<'splitPdf'>): CommandResult<'splitPdf'> => {
   return await call('splitPdf', args)
 }
 
-export async function addPassword (...args: CommandArgs<'addPassword'>): CommandResult<'addPassword'> {
+export const addPassword: typeof core.addPassword = async (...args: CommandArgs<'addPassword'>): CommandResult<'addPassword'> => {
   return await call('addPassword', args)
 }
 
-export async function removePassword (...args: CommandArgs<'removePassword'>): CommandResult<'removePassword'> {
+export const removePassword: typeof core.removePassword = async (...args: CommandArgs<'removePassword'>): CommandResult<'removePassword'> => {
   return await call('removePassword', args)
 }
 
-export async function renderPageAsImage (...args: CommandArgs<'renderPageAsImage'>): CommandResult<'renderPageAsImage'> {
+export const renderPageAsImage: typeof core.renderPageAsImage = async (...args: CommandArgs<'renderPageAsImage'>): CommandResult<'renderPageAsImage'> => {
   return await call('renderPageAsImage', args)
 }
 
-export async function getInfo (...args: CommandArgs<'getInfo'>): CommandResult<'getInfo'> {
+export const getInfo: typeof core.getInfo = async (...args: CommandArgs<'getInfo'>): CommandResult<'getInfo'> => {
   return await call('getInfo', args)
 }

packages/ghoulscript/src/rpc.ts

@@ -1,6 +1,6 @@
-import * as core from './core.js'
-
-let worker: Worker
+import type { Config } from './config'
+import { getWorkerURL, useConfig } from './config'
+import * as core from './core'
 
 export type Core = typeof core
 
@@ -16,20 +16,33 @@ export interface RPC <C extends Commands = any> {
   id: number,
   name: C,
   args: CommandArgs<C>,
+  config: Config,
 }
 
 export interface RPCResult<C extends Commands = any> {
   id: number,
   result: CommandResult<C>,
+  error?: undefined,
 }
 
+let worker: Worker
+
 export function useWorkerRPC () {
-  if (!worker)
-    worker = new Worker(new URL('rpc.worker', import.meta.url))
+  if (!worker) {
+    const url = useConfig().useCDN
+      ? getWorkerURL()
+      : new URL('rpc.worker.mjs', import.meta.url)
+
+    worker = new Worker(url, { type: 'module' })
+  }
 
   return worker
 }
 
+export function setWorkerRPC (worker_: Worker) {
+  worker = worker_
+}
+
 export async function callWorkerRPC<C extends Commands, A extends CommandArgs<C>> (name: C, args: A) {
   return await new Promise<CommandResult<C>>((resolve, reject) => {
     const id     = Date.now()
@@ -38,7 +51,11 @@ export async function callWorkerRPC<C extends Commands, A extends CommandArgs<C>
     const onMessage = (event: MessageEvent<RPCResult<C>>) => {
       if (event.data.id === id) {
         cleanUp()
-        resolve(event.data.result)
+
+        if (event.data.error)
+          reject(event.data.error)
+        else
+          resolve(event.data.result)
       }
     }
 
@@ -56,9 +73,10 @@ export async function callWorkerRPC<C extends Commands, A extends CommandArgs<C>
     worker.addEventListener('error', onError)
 
     worker.postMessage({
-      id  : id,
-      name: name,
-      args: args,
+      id    : id,
+      name  : name,
+      args  : args,
+      config: useConfig(),
     })
   })
 }

packages/ghoulscript/src/rpc.worker.ts

@@ -1,12 +1,16 @@
 /* eslint-disable @typescript-eslint/triple-slash-reference */
 /* eslint-env serviceworker */
 
-import type { RPC } from './rpc.js'
-import { callRPC } from './rpc.js'
+import type { RPC } from './rpc'
+import { callRPC } from './rpc'
+import { configureGS } from './config'
 
 self.addEventListener('message', (event: MessageEvent<RPC>) => {
-  const rpc = event.data
-  const id  = rpc.id
+  const rpc    = event.data
+  const id     = rpc.id
+  const config = rpc.config
+
+  configureGS(config)
 
   callRPC(rpc.name, rpc.args)
     .then((result) => {
@@ -16,6 +20,9 @@ self.addEventListener('message', (event: MessageEvent<RPC>) => {
       })
     })
     .catch((error) => {
-      throw error
+      self.postMessage({
+        id,
+        error,
+      })
     })
 })

packages/ghoulscript/tests/sample.ts

@@ -9,7 +9,7 @@ import {
   removePassword,
   renderPageAsImage,
   splitPdf,
-} from '../src/index.js'
+} from '../dist'
 
 const _filename = fileURLToPath(import.meta.url)
 const _dirname  = dirname(_filename)