JSDocumentor

MMO\doc · 1 symbol · generated 30 Sep 2026

class

JSDocumentor

Generates the javascript documentation of a package, exactly the way Documentor generates its php one.

class MMO\doc\JSDocumentor extends MMO\core\classes\aModule

Namespace: MMO\doc
Extends: aModule
See: Parser the javascript parser, JHSParser the .jhs custom element parser

Same model, same output, same navigation: one `.md` page plus its `.doc.json` model per file, and one `index.json` search index per language folder -- so a javascript symbol is searchable, linkable and renderable through the very same controllers as a php one. The only real difference is where the information comes from: there is no reflection for javascript, so the sources are read straight out. ### Where pages land Under `<the package's documentation folder>/js`, and which path inside it depends on the source: | source | mode | page | |---|---|---| | `src/js/core/functions/strings.js` declaring `MMO.core.strings` | namespace | `js/core/strings.md` | | `src/js/core/Map.js` declaring `MMO.core.Map` | namespace | `js/core/Map.md` | | `src/customElements/inputs/mmo-radio.jhs` | path | `js/elements/inputs/mmo-radio.md` | In namespace mode the root namespace (`MMO`) maps to the root folder, exactly as php's root namespace maps to `docs/php` -- so the tree reads the same in both languages.

\MMO\doc\JSDocumentor::Shared()->generate('mmo.client');

Index

	folders
	output
	rootNamespace
	sources
	buildIndex($pages, $targets, $root)	Write the `index.json` the search box reads (`SearchController`), in the same shape `Documentor::buildIndex` writes for php.
	buildTargets($pages, $manifest)	Map every documented symbol name onto where it can be linked: the markdown file (for relative links between pages) and the browsable page path, which the html renderer turns into a url at render time.
	DefaultConfig() static
	generate($libraries)	Generate the javascript documentation of one or several installed packages.
	generateLibrary($manifest)
	getOutputFolder($manifest)
	namespaceModePath($symbol)	In namespace mode the page is the symbol's namespace turned into a path, with the root namespace mapped onto the root folder -- `MMO.core.Map` becomes `core/Map`, `MMO.core.strings.bytesize` become…
	pageFor($pages, $symbol, $root, $source, $manifest)	Find (or create) the page a symbol belongs on.
	pagePath($manifest, $page)
	parseFile($filename)
	pathModePath($source)	In path mode the page mirrors the source tree: `inputs/mmo-radio.jhs` under a prefix of `elements` becomes `elements/inputs/mmo-radio`.
	resolveReference($reference, $targets)
	resolveSymbol($symbol, $targets)	Fill in every reference of a symbol -- its parent, the types of its members, parameters and returns -- with where that name is documented, now that every page is known.
	resolveType($type, $targets)
	resolveTypes($node, $targets)
	sourceFiles($manifest)
	stripRoot($name)

Properties4

folders

array $folders = []

Type: array

output

string $output = 'js'

Type: string

rootNamespace

string $rootNamespace = 'MMO'

Type: string

sources

array $sources = []

Type: array

Methods17

buildIndex($pages, $targets, $root)

JSDocumentor.php:373

Write the index.json the search box reads (SearchController), in the same shape Documentor::buildIndex writes for php.

protected function buildIndex(array $pages, array $targets, string $root): array

$pages	array
$targets	array
$root	string	the package's javascript output folder
returns	array	the index

buildTargets($pages, $manifest)

JSDocumentor.php:258

Map every documented symbol name onto where it can be linked: the markdown file (for relative links between pages) and the browsable page path, which the html renderer turns into a url at render time.

protected function buildTargets(array $pages, object $manifest): array

See: Documentor::getPagePath why a url is never baked in here

$pages	array
$manifest	object
returns	array	string, anchor: string, page: string, short: string}>

DefaultConfig()

staticJSDocumentor.php:53

static function DefaultConfig(): array

returns

array

generate($libraries)

JSDocumentor.php:73

Generate the javascript documentation of one or several installed packages.

function generate(string ...$libraries): void

...$libraries	string
returns	void

generateLibrary($manifest)

JSDocumentor.php:89

function generateLibrary(object $manifest): array

$manifest	object
returns	array	the pages written, keyed by their markdown filename (empty when the package ships no javascript at all)

getOutputFolder($manifest)

JSDocumentor.php:172

function getOutputFolder(object $manifest): string

$manifest	object
returns	string	the absolute folder the package's javascript pages are written into.

namespaceModePath($symbol)

JSDocumentor.php:231

In namespace mode the page is the symbol's namespace turned into a path, with the root namespace mapped onto the root folder -- MMO.core.Map becomes core/Map, MMO.core.strings.bytesize becomes core/strings, and anything sitting directly in the root namespace lands on index.

protected function namespaceModePath(MMO\doc\models\DocSymbol $symbol): string

$symbol	DocSymbol
returns	string

pageFor($pages, $symbol, $root, $source, $manifest)

JSDocumentor.php:193

Find (or create) the page a symbol belongs on.

protected function pageFor( array &$pages, MMO\doc\models\DocSymbol $symbol, string $root, array $source, object $manifest ): MMO\doc\models\DocPage

$pages	array
$symbol	DocSymbol
$root	string	the package's javascript output folder
$source	array	the `sources` entry the file was found through
$manifest	object
returns	DocPage

pagePath($manifest, $page)

JSDocumentor.php:288

protected function pagePath(object $manifest, MMO\doc\models\DocPage $page): string

$manifest	object
$page	DocPage
returns	string	the page's browsable path, matching `Documentor::getPagePath`'s own scheme.

parseFile($filename)

JSDocumentor.php:135

function parseFile(string $filename): array

$filename	string
returns	array	whatever the right parser reads out of that file

pathModePath($source)

JSDocumentor.php:217

In path mode the page mirrors the source tree: inputs/mmo-radio.jhs under a prefix of elements becomes elements/inputs/mmo-radio.

protected function pathModePath(array $source): string

$source	array
returns	string

resolveReference($reference, $targets)

JSDocumentor.php:357

protected function resolveReference(array $reference, array $targets): array

$reference	array
$targets	array
returns	array	the reference, pointing at wherever that name is documented.

resolveSymbol($symbol, $targets)

JSDocumentor.php:299

Fill in every reference of a symbol -- its parent, the types of its members, parameters and returns -- with where that name is documented, now that every page is known.

protected function resolveSymbol(MMO\doc\models\DocSymbol $symbol, array $targets): void

$symbol	DocSymbol
$targets	array
returns	void

resolveType($type, $targets)

JSDocumentor.php:344

protected function resolveType(?array $type, array $targets): ?array

$type	null \| array
$targets	array
returns	null \| array	the type, with every atom that names a documented symbol linked to it.

resolveTypes($node, $targets)

JSDocumentor.php:319

protected function resolveTypes(MMO\doc\models\DocNode $node, array $targets): void

$node	DocNode	a symbol or a member
$targets	array
returns	void

sourceFiles($manifest)

JSDocumentor.php:153

function sourceFiles(object $manifest): array

$manifest	object
returns	array	string, 1: array}> every javascript/jhs source of the package, with the `sources` entry it was found through

stripRoot($name)

JSDocumentor.php:241

protected function stripRoot(string $name): string

$name	string
returns	string	$name without its leading root namespace segment.

Inherited members (47)

Constants	Declared by	Description
`ALERT`	iLogLevel	Alert: Action must be taken immediately.
`ALL`	iLogLevel	Mask for all
`ALL_PLUS`	iLogLevel	debug everything
`BACKTRACE`	iLogLevel
`CRITICAL`	iLogLevel	Critical: Critical conditions.
`DEBUG`	iLogLevel	Debug: Detailed debug information.
`DEEP`	iLogLevel	debug everything with arguments
`EMERGENCY`	iLogLevel	Emergency: System is unusable.
`ERROR`	iLogLevel	Error: Runtime errors that do not require immediate action but should typically be logged and monitored.
`ERROR_PLUS`	iLogLevel	Mask for all error
`FATAL`	iLogLevel	Mask for all fatal error
`INFO`	iLogLevel	Info: Interesting events.
`INFO_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`MEMORY`	iLogLevel	include backtrace object
`NOTICE`	iLogLevel	Notice: Normal but significant events.
`NOTICE_PLUS`	iLogLevel	Mask for all errors/warning/notices/info
`TRACE`	iLogLevel	include backtrace as origins
`WARNING`	iLogLevel	Warning: Exceptional occurrences that are not errors.
`WARNING_PLUS`	iLogLevel	Mask for all errors and warnings

	Properties	Declared by	Description
	`verbosity`	aModule

Methods	Declared by	Description
`alert($message, $context)`	aModule	Action must be taken immediately.
`backtraces($message, $context)`	aModule	Force-log a message at INFO level together with a full stack trace/memory snapshot (`iLogLevel::BACKTRACE`), bypassing the verbosity mask entirely (any non-zero verbosity is enough to trigger it).
`Configure($config)`	aModule	Merge $config into this module's configuration in the shared `Configuration`.
`critical($message, $context)`	aModule	Critical conditions. No-op if CRITICAL is currently filtered out by the verbosity mask.
`debug($message, $context)`	aModule	Detailed debug information.
`debugName()`	aModule	Human-readable identifier used as the default `{origin}` in this instance's log messages.
`emergency($message, $context)`	aModule	System is unusable. No-op if EMERGENCY is currently filtered out by the verbosity mask.
`error($message, $context)`	aModule	Runtime errors that do not require immediate action but should typically be logged and monitored.
`getVerbosity()`	aModule
`info($message, $context)`	aModule	Interesting events. No-op if INFO is currently filtered out by the verbosity mask.
`Instantiate($config)`	aModule	(Re)create the shared instance immediately, configured with $config merged into the class's existing config.
`IsShared()`	aModule
`log($level, $message, $context)`	aModule	Logs with an arbitrary level.
`notice($message, $context)`	aModule	Normal but significant events.
`offsetExists($key)`	aModule	\ArrayAccess::offsetExists -- tells whether $key is a declared property at all, regardless of whether it is currently readable/writable through array access.
`offsetGet($key)`	aModule	\ArrayAccess::offsetGet -- reads a property directly, unless it has a `#[Serialize(serialize: 'methodName')]` attribute, in which case that zero-argument method is called instead (e.g.
`offsetSet($key, $value)`	aModule	\ArrayAccess::offsetSet -- sets a property directly, unless it has a `#[Serialize(unserialize: 'methodName')]` attribute, in which case that method is called with $value instead (e.g.
`offsetUnset($key)`	aModule	\ArrayAccess::offsetUnset -- equivalent to `$module[$key] = null`.
`serialize($path, $serializer)`	aModule	\MMO\core\interfaces\iSerializable::serialize -- exports every property (via
`setVerbosity($verb)`	aModule	Set the current verbosity mask, replacing whatever it was before.
`Shared()`	aModule	Get the shared instance, creating (and configuring) it on first call.
`testVerbosity($level)`	aModule	Test whether a given level (or set of levels) is currently enabled by this instance's verbosity mask.
`traitUnshare($serialize)`	aModule	Remove the shared instance, so the next `Shared()` call creates a fresh one.
`unserialize($data, $path, $instances)`	aModule	\MMO\core\interfaces\iSerializable::unserialize -- merges $data onto `DefaultConfig`, runs it through the (possibly overridden) constructor, then applies each resulting value to its property (via
`Unshare($serialize)`	aModule	Like `tSingleton::Unshare`, but also disconnects this module's instance from every event it was listening to (via `Event::DisconnectListeners`) before dropping it.
`warning($message, $context)`	aModule	Exceptional occurrences that are not errors.
`__construct($config)`	aModule	protected constructor, so it is not possible to do `new Module(...)` called by the serialization process just before being injected with data.