Typedoc ignores lots of exported module elements

[evil-shrike]

Given a ts module (file), let's call it "core.ts"

import * as lang from "lib/core.lang";
import * as binding from "lib/binding";
import * as events from "lib/core.events";
import * as composition from "lib/core.composition";
import diagnostics = require("lib/core.diagnostics");
import * as commands from "lib/core.commands";
import html = require("lib/core.html");
import * as eth from "lib/core.eth";

export {
	lang,
	binding,
	events,
	composition,
	diagnostics,
	commands,
	html,
	eth
};

import { ui as coreui, interop as coreinterop } from "core";

export let ui: typeof coreui = <any>{
	Part: Part,
	StatefulPart: StatefulPart,
	Component: Component,
	View: View
};
export namespace ui {}

// class `Application` refers to `interop`, we have to declare it
export declare let interop: typeof coreinterop;
export declare namespace interop {}

export import createCommand = commands.createCommand;
import {isHtml, SafeHtml, safeHtml} from "lib/formatters";
export {isHtml, SafeHtml, safeHtml};

So it's expected that core module to contain:

• nested modules lang, binding, events, composition, diagnostics, commands, html, eth
• ui submodule with fields of declared "core.ui" namespace - not sure here what should be in doc: declared fields (see below) or actually assigned (with classes Part, StatefulPart, Component, View), I think the former
• interop submodule with fields of declared "core.interop" namespace
• function createCommand
• isHtml, SafeHtml, safeHtml

There're declare module "core.interop" and declare module "core.ui" in core.all.d.ts.

Unfortunately almost nothing of the mentioned elements got into doc.
There're two submodules/namespace in doc - ui and interop, but they are empty.

There're indeed global modules "core.lang", "core.bindining" and so on, but it's not the same as exported values in core right. Because that export { lang } in core.ts means that I can get object from module's filed core.lang (even in js), where core is import core = require("core").

This is not all. I have lots of module with a single exported class like:

class ObjectEditor {
}
export = ObjectEditor;

but it's common practice to include interfaces for that class inside namespace:

class ObjectEditor {
}
namespace ObjectEditor {
	export interface Options {}
}
export = ObjectEditor;

That ObjectEditor.Options can be used everywhere where module with ObjectEditor class imported. But TypeDoc completely ignores such interfaces (inside exported namespaces).

[aciccarello]

From skimming your issue, I think most of the problems are related to #472. Currently, namespace merging does not work well. Some design work is definitely needed.

[evil-shrike]

@aciccarello it seems it's about the last problem - right, declaration merging is the correct term for this.

but there's other problems, why for example this function is ignored?

export import createCommand = commands.createCommand;

[Gerrit0]

but there's other problems, why for example this function is ignored?

I believe this is because TypeDoc doesn't handle ImportEqualsDeclaration nodes, that's a whole other issue though. (I also don't think it should be used, import <name> = is used when using require in TS sources, which isn't exactly encouraged anymore, especially now that TS has a helper to automatically convert files to ES modules).

Closing in favor of #712, #801 should fix the missing symbols once merged.