5406352152

import type { Node } from 'estree'
import { memoize } from 'lodash'

import type { Context } from '..'
import { timeoutPromise } from '../utils'
import { wrapSourceModule } from '../utils/operators'
import { ModuleConnectionError, ModuleInternalError, ModuleNotFoundError } from './errors'
import { MODULES_STATIC_URL } from './moduleLoader'
import type { ModuleBundle, ModuleDocumentation, ModuleManifest } from './moduleTypes'
import { getRequireProvider } from './requireProvider'

export function httpGetAsync(path: string, type: 'json'): Promise<object>
export function httpGetAsync(path: string, type: 'text'): Promise<string>
export async function httpGetAsync(path: string, type: 'json' | 'text') {
  try {
    const resp = await fetch(path, {
      method: 'GET'
    })

    if (resp.status !== 200 && resp.status !== 304) {
      throw new ModuleConnectionError()
    }

    const promise = type === 'text' ? resp.text() : resp.json()
    if (typeof window === 'undefined') {
      return timeoutPromise(promise, 10000)
    }
    return promise
  } catch (error) {
    if (error instanceof TypeError) throw new ModuleConnectionError()
    if (!(error instanceof ModuleConnectionError)) throw new ModuleInternalError(path, error)
    throw error
  }
}

/**
 * Send a HTTP GET request to the modules endpoint to retrieve the manifest
 * @return Modules
 */
export const memoizedGetModuleManifestAsync = memoize(getModuleManifestAsync)
function getModuleManifestAsync(): Promise<ModuleManifest> {
  return httpGetAsync(`${MODULES_STATIC_URL}/modules.json`, 'json') as Promise<ModuleManifest>
}

async function checkModuleExists(moduleName: string, node?: Node) {
  const modules = await memoizedGetModuleManifestAsync()
  // Check if the module exists
  if (!(moduleName in modules)) throw new ModuleNotFoundError(moduleName, node)

  return modules[moduleName]
}

export const memoizedGetModuleBundleAsync = memoize(getModuleBundleAsync)
async function getModuleBundleAsync(moduleName: string): Promise<string> {
  return httpGetAsync(`${MODULES_STATIC_URL}/bundles/${moduleName}.js`, 'text')
}

export const memoizedGetModuleTabAsync = memoize(getModuleTabAsync)
function getModuleTabAsync(tabName: string): Promise<string> {
  return httpGetAsync(`${MODULES_STATIC_URL}/tabs/${tabName}.js`, 'text')
}

export const memoizedGetModuleDocsAsync = memoize(getModuleDocsAsync)
async function getModuleDocsAsync(moduleName: string): Promise<ModuleDocumentation | null> {
  try {
    const result = await httpGetAsync(`${MODULES_STATIC_URL}/jsons/${moduleName}.json`, 'json')
    return result as ModuleDocumentation
  } catch (error) {
    console.warn(`Failed to load documentation for ${moduleName}:`, error)
    return null
  }
}

export async function loadModuleTabsAsync(moduleName: string, node?: Node) {
  const moduleInfo = await checkModuleExists(moduleName, node)

  // Load the tabs for the current module
  return Promise.all(
    moduleInfo.tabs.map(async path => {
      const rawTabFile = await memoizedGetModuleTabAsync(path)
      try {
        return eval(rawTabFile)
      } catch (error) {
        // console.error('tab error:', error);
        throw new ModuleInternalError(path, error, node)
      }
    })
  )
}

export async function loadModuleBundleAsync(
  moduleName: string,
  context: Context,
  wrapModule: boolean,
  node?: Node
) {
  // await checkModuleExists(moduleName, node)
  const moduleText = await memoizedGetModuleBundleAsync(moduleName)
  try {
    const moduleBundle: ModuleBundle = eval(moduleText)

    if (wrapModule) return wrapSourceModule(moduleName, moduleBundle, getRequireProvider(context))
    return moduleBundle(getRequireProvider(context))
  } catch (error) {
    // console.error("bundle error: ", error)
    throw new ModuleInternalError(moduleName, error, node)
  }
}

1	import type { Node } from 'estree'
2	import { memoize } from 'lodash'	1✔
3
4	import type { Context } from '..'
5	import { timeoutPromise } from '../utils'	1✔
6	import { wrapSourceModule } from '../utils/operators'	1✔
7	import { ModuleConnectionError, ModuleInternalError, ModuleNotFoundError } from './errors'	1✔
8	import { MODULES_STATIC_URL } from './moduleLoader'	1✔
9	import type { ModuleBundle, ModuleDocumentation, ModuleManifest } from './moduleTypes'
10	import { getRequireProvider } from './requireProvider'	1✔
11
12	export function httpGetAsync(path: string, type: 'json'): Promise<object>
13	export function httpGetAsync(path: string, type: 'text'): Promise<string>
14	export async function httpGetAsync(path: string, type: 'json' \| 'text') {	1✔
15	try {	12✔
16	const resp = await fetch(path, {	12✔
17	method: 'GET'
18	})
19
20	if (resp.status !== 200 && resp.status !== 304) {	11✔
21	throw new ModuleConnectionError()	1✔
22	}
23
24	const promise = type === 'text' ? resp.text() : resp.json()	10✔
25	if (typeof window === 'undefined') {	10!
26	return timeoutPromise(promise, 10000)	×
27	}
28	return promise	10✔
29	} catch (error) {
30	if (error instanceof TypeError) throw new ModuleConnectionError()	2✔
31	if (!(error instanceof ModuleConnectionError)) throw new ModuleInternalError(path, error)	1!
32	throw error	1✔
33	}
34	}
35
36	/**
37	* Send a HTTP GET request to the modules endpoint to retrieve the manifest
38	* @return Modules
39	*/
40	export const memoizedGetModuleManifestAsync = memoize(getModuleManifestAsync)	1✔
41	function getModuleManifestAsync(): Promise<ModuleManifest> {
42	return httpGetAsync(`${MODULES_STATIC_URL}/modules.json`, 'json') as Promise<ModuleManifest>	2✔
43	}
44
45	async function checkModuleExists(moduleName: string, node?: Node) {
46	const modules = await memoizedGetModuleManifestAsync()	1✔
47	// Check if the module exists
48	if (!(moduleName in modules)) throw new ModuleNotFoundError(moduleName, node)	1!
49
50	return modules[moduleName]	1✔
51	}
52
53	export const memoizedGetModuleBundleAsync = memoize(getModuleBundleAsync)	1✔
54	async function getModuleBundleAsync(moduleName: string): Promise<string> {
55	return httpGetAsync(`${MODULES_STATIC_URL}/bundles/${moduleName}.js`, 'text')	3✔
56	}
57
58	export const memoizedGetModuleTabAsync = memoize(getModuleTabAsync)	1✔
59	function getModuleTabAsync(tabName: string): Promise<string> {
60	return httpGetAsync(`${MODULES_STATIC_URL}/tabs/${tabName}.js`, 'text')	3✔
61	}
62
63	export const memoizedGetModuleDocsAsync = memoize(getModuleDocsAsync)	1✔
64	async function getModuleDocsAsync(moduleName: string): Promise<ModuleDocumentation \| null> {
65	try {	×
66	const result = await httpGetAsync(`${MODULES_STATIC_URL}/jsons/${moduleName}.json`, 'json')	×
67	return result as ModuleDocumentation	×
68	} catch (error) {
69	console.warn(`Failed to load documentation for ${moduleName}:`, error)	×
70	return null	×
71	}
72	}
73
74	export async function loadModuleTabsAsync(moduleName: string, node?: Node) {	1✔
75	const moduleInfo = await checkModuleExists(moduleName, node)	1✔
76
77	// Load the tabs for the current module
78	return Promise.all(	1✔
79	moduleInfo.tabs.map(async path => {	2✔
80	const rawTabFile = await memoizedGetModuleTabAsync(path)	2✔
81	try {	2✔
82	return eval(rawTabFile)	2✔
83	} catch (error) {
84	// console.error('tab error:', error);
85	throw new ModuleInternalError(path, error, node)	2✔
86	}
87	})
88	)
89	}
90
91	export async function loadModuleBundleAsync(	1✔
92	moduleName: string,
93	context: Context,
94	wrapModule: boolean,
95	node?: Node
96	) {
97	// await checkModuleExists(moduleName, node)
98	const moduleText = await memoizedGetModuleBundleAsync(moduleName)	2✔
99	try {	2✔
100	const moduleBundle: ModuleBundle = eval(moduleText)	2✔
101
102	if (wrapModule) return wrapSourceModule(moduleName, moduleBundle, getRequireProvider(context))	1!
103	return moduleBundle(getRequireProvider(context))	1✔
104	} catch (error) {
105	// console.error("bundle error: ", error)
106	throw new ModuleInternalError(moduleName, error, node)	1✔
107	}
108	}

source-academy / js-slang / 5406352152

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous