80 | ${htmlEscape(message)}
81 |
82 | 
4 |
5 | Docuraptor is an offline alternative to the [doc.deno.land](https://doc.deno.land) service.
6 |
7 | It generates and serves HTML documentation for JS/TS modules with the help of [Deno's](https://deno.land) documentation parser.
8 |
9 | ## Features
10 |
11 | - Offline documentation
12 | - Usable without browser JavaScript, for example in `w3m`
13 | - Dark and Light theme
14 |
15 | ## Installation
16 |
17 | `$ deno install -A https://deno.land/x/docuraptor@20200930.0/docuraptor.ts`
18 |
19 | The permissions can be restricted.
20 | Read the `--help` documentation for more details.
21 |
22 | ## Usage
23 |
24 | `$ deno run https://deno.land/x/docuraptor@20200930.0/docuraptor.ts --help`
25 |
26 | ## Examples
27 |
28 | 
29 | _Docuraptor with `BROWSER=w3m`_
30 |
31 | 
32 |
--------------------------------------------------------------------------------
/assets.ts:
--------------------------------------------------------------------------------
1 | interface Asset {
2 | content: string;
3 | mimetype?: string;
4 | }
5 |
6 | const assets: { [name: string]: Asset } = {
7 | css: {
8 | content: `
9 | :root {
10 | color: #111;
11 | }
12 |
13 | body {
14 | margin: 0;
15 | }
16 |
17 | div.metadata {
18 | border: 0.1em solid gray;
19 | margin: 1em 0;
20 | padding: 1ch;
21 | }
22 |
23 | img.logo {
24 | width: 5ch;
25 | }
26 |
27 | header {
28 | display: flex;
29 | flex-wrap: wrap;
30 | justify-content: center;
31 | margin: 0.5em;
32 | }
33 |
34 | header * {
35 | align-self: center;
36 | margin: 0 0.5ch;
37 | }
38 |
39 | hr {
40 | border: 0.05em dashed #bbb;
41 | }
42 |
43 | li {
44 | border: 0.1em solid #bbb;
45 | margin: 0.2em;
46 | padding: 0.5em 1ch;
47 | }
48 |
49 | li.namespace {
50 | background: #ddd;
51 | }
52 |
53 | li.node {
54 | background: #eee;
55 | }
56 |
57 | li.node li {
58 | font-size: 0.9em;
59 | }
60 |
61 | ol {
62 | margin: 0;
63 | }
64 |
65 | main {
66 | flex-grow: 1;
67 |
68 | font-family: monospace;
69 | font-size: 1.2rem;
70 | }
71 |
72 | nav.sidebar {
73 | background: #eee;
74 | border: 0.1em solid gray;
75 |
76 | box-sizing: border-box;
77 | flex-basis: 25%;
78 | flex-shrink: 0;
79 | height: 100vh;
80 | max-width: 30ch;
81 | overflow: auto;
82 |
83 | position: sticky;
84 | top: 0;
85 |
86 | z-index: 5;
87 | }
88 |
89 | ol.noborder li {
90 | border-style: none;
91 | padding: 0 1ch;
92 | }
93 |
94 | ol.nomarks {
95 | list-style-type: none;
96 | padding-left: 0;
97 | }
98 |
99 | ol.indent {
100 | padding: 0 2ch;
101 | }
102 |
103 | pre {
104 | white-space: pre-wrap;
105 | font-size: 0.9em;
106 | }
107 |
108 | span.exkeyword {
109 | color: #005959;
110 | }
111 |
112 | span.iconize {
113 | display: inline-block;
114 | height: 1em;
115 | margin: 0.2em;
116 | padding: 0.1em;
117 | width: 1em;
118 |
119 | font-family: monospace;
120 | font-weight: bold;
121 | line-height: 1em;
122 | text-align: center;
123 | vertical-align: middle;
124 |
125 | color: black;
126 | background: red;
127 | }
128 |
129 | span.icon-class {
130 | background: #a8e;
131 | }
132 |
133 | span.icon-enum {
134 | background: #6af;
135 | }
136 |
137 | span.icon-function {
138 | background: #fd6;
139 | }
140 |
141 | span.icon-green {
142 | background: lightgreen;
143 | }
144 |
145 | span.icon-import {
146 | background:white;
147 | }
148 |
149 | span.icon-interface {
150 | background: #d8d;
151 | }
152 |
153 | span.icon-namespace {
154 | background: silver;
155 | }
156 |
157 | span.icon-orange {
158 | background: orange;
159 | }
160 |
161 | span.icon-typeAlias {
162 | background: #7bf;
163 | }
164 |
165 | span.icon-variable {
166 | background: #aea;
167 | }
168 |
169 | span.icon-white {
170 | background: white;
171 | }
172 |
173 | span.identifier {
174 | color: black;
175 | font-weight: bold;
176 | }
177 |
178 | span.keyword {
179 | color: darkmagenta;
180 | }
181 |
182 | span.literal {
183 | color: green;
184 | }
185 |
186 | span.typeref {
187 | color: navy;
188 | }
189 |
190 | span.unimplemented {
191 | color: #f44;
192 | background: #224;
193 | border: 0.2em dashed red;
194 | font-size: 0.8em;
195 | }
196 |
197 | .fill {
198 | flex-grow: 1;
199 | }
200 |
201 | .hor-flex {
202 | display: flex;
203 | flex-direction: row;
204 | }
205 |
206 | .inline {
207 | display: inline-block;
208 | }
209 |
210 | .monospace {
211 | font-family: monospace;
212 | }
213 |
214 | .notextwrap {
215 | white-space: nowrap;
216 | }
217 |
218 | .nowrap {
219 | display: inline-flex;
220 | flex-wrap: nowrap;
221 | }
222 |
223 | .padding {
224 | padding: 0.2em 1em;
225 | }
226 |
227 | @media(prefers-color-scheme: dark) {
228 | :root {
229 | color: #eee;
230 | background: #111;
231 | }
232 |
233 | a:link {
234 | color: cornflowerblue;
235 | }
236 |
237 | a:visited {
238 | color: dodgerblue;
239 | }
240 |
241 | li.link {
242 | background: #222;
243 | }
244 |
245 | li.namespace {
246 | background: #333;
247 | }
248 |
249 | li.node {
250 | background: #222;
251 | }
252 |
253 | nav.sidebar {
254 | background: #222;
255 | font-family: sans;
256 | }
257 |
258 | span.exkeyword {
259 | color: #00c1c1;
260 | }
261 |
262 | span.identifier {
263 | color: white;
264 | }
265 |
266 | span.keyword {
267 | color: violet;
268 | }
269 |
270 | span.literal {
271 | color: lightgreen;
272 | }
273 |
274 | span.typeref {
275 | color: deepskyblue;
276 | }
277 | }
278 |
279 | span a:link {
280 | color: inherit;
281 | text-decoration: inherit;
282 | }
283 |
284 | span a:visited {
285 | color: inherit;
286 | text-decoration: inherit;
287 | }
288 | `,
289 | mimetype: "text/css",
290 | },
291 | logo: {
292 | content: `
293 | `,
294 | mimetype: "image/svg+xml",
295 | },
296 | script: {
297 | content: ``,
298 | mimetype: "application/javascript",
299 | },
300 | };
301 | export default assets;
302 |
--------------------------------------------------------------------------------
/assets/LICENSE:
--------------------------------------------------------------------------------
1 | This work is licensed under the Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.
2 | To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/ or send a letter to Creative Commons, PO Box 1866, Mountain View, CA 94042, USA.
3 |
--------------------------------------------------------------------------------
/assets/logo.optimized.svg:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/assets/logo.svg:
--------------------------------------------------------------------------------
1 |
2 |
200 |
--------------------------------------------------------------------------------
/assets/screenshot.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SyrupThinker/docuraptor/9071dd18654e7f13d393a99a5fbbc5d9a19afacc/assets/screenshot.png
--------------------------------------------------------------------------------
/deno_api.ts:
--------------------------------------------------------------------------------
1 | import type * as ddoc from "./deno_doc_json.ts";
2 | import type * as info from "./deno_info_json.ts";
3 |
4 | const decoder = new TextDecoder();
5 |
6 | export async function getDenoData(
7 | specifier?: string,
8 | { private: priv }: { private?: boolean } = {},
9 | ): Promise<{ doc: ddoc.DocNode[]; info: info.FileInfo | null }> {
10 | let proc_d;
11 | let proc_i;
12 | try {
13 | proc_d = Deno.run({
14 | cmd: [
15 | "deno",
16 | "doc",
17 | "--json",
18 | ...(priv ? ["--private"] : []),
19 | specifier ?? "--builtin",
20 | ],
21 | stdin: "null",
22 | stdout: "piped",
23 | stderr: "piped",
24 | });
25 |
26 | const stdout = decoder.decode(await proc_d.output());
27 | const stderr = decoder.decode(await proc_d.stderrOutput());
28 | const { success } = await proc_d.status();
29 |
30 | if (!success) {
31 | throw { stderr };
32 | }
33 |
34 | const doc_j: ddoc.DocNode[] = JSON.parse(stdout);
35 | let info_j: info.FileInfo | null = null;
36 |
37 | if (specifier !== undefined) {
38 | proc_i = Deno.run({
39 | cmd: [
40 | "deno",
41 | "info",
42 | "--json",
43 | "--unstable",
44 | specifier,
45 | ],
46 | stdin: "null",
47 | stdout: "piped",
48 | stderr: "piped",
49 | });
50 |
51 | const stdout = decoder.decode(await proc_i.output());
52 | const stderr = decoder.decode(await proc_i.stderrOutput());
53 | const { success } = await proc_i.status();
54 |
55 | if (!success) {
56 | throw { stderr };
57 | }
58 |
59 | info_j = JSON.parse(stdout);
60 | }
61 |
62 | return { doc: doc_j, info: info_j };
63 | } finally {
64 | proc_d?.close();
65 | proc_i?.close();
66 | }
67 | }
68 |
--------------------------------------------------------------------------------
/deno_doc_json.ts:
--------------------------------------------------------------------------------
1 | export type Accessibility = "public" | "protected" | "private";
2 |
3 | export interface ClassConstructorDef {
4 | jsDoc: string | null;
5 | accessibility: Accessibility | null;
6 | name: string;
7 | params: ParamDef[];
8 | location: Location;
9 | }
10 |
11 | export interface ClassDef {
12 | isAbstract: boolean;
13 | constructors: ClassConstructorDef[];
14 | properties: ClassPropertyDef[];
15 | indexSignatures: ClassIndexSignatureDef[];
16 | methods: ClassMethodDef[];
17 | extends: string | null;
18 | implements: TsTypeDef[];
19 | typeParams: TsTypeParamDef[];
20 | superTypeParams: TsTypeDef[];
21 | }
22 |
23 | export interface ClassIndexSignatureDef {
24 | readonly: boolean;
25 | params: ParamDef[];
26 | tsType: TsTypeDef | null;
27 | }
28 |
29 | export interface ClassMethodDef {
30 | jsDoc: string | null;
31 | accessibility: Accessibility | null;
32 | optional: boolean;
33 | isAbstract: boolean;
34 | isStatic: boolean;
35 | name: string;
36 | kind: MethodKind;
37 | functionDef: FunctionDef;
38 | location: Location;
39 | }
40 |
41 | export interface ClassPropertyDef {
42 | jsDoc: string | null;
43 | tsType: TsTypeDef;
44 | readonly: boolean;
45 | accessibility: Accessibility | null;
46 | optional: boolean;
47 | isAbstract: boolean;
48 | isStatic: boolean;
49 | name: string;
50 | location: Location;
51 | }
52 |
53 | export type DocNode =
54 | | DocNodeClass
55 | | DocNodeEnum
56 | | DocNodeFunction
57 | | DocNodeImport
58 | | DocNodeInterface
59 | | DocNodeNamespace
60 | | DocNodeTypeAlias
61 | | DocNodeVariable;
62 |
63 | export interface DocNodeBase {
64 | name: string;
65 | location: Location;
66 | jsDoc: string | null;
67 | }
68 |
69 | export interface DocNodeClass extends DocNodeBase {
70 | kind: "class";
71 | classDef: ClassDef;
72 | }
73 |
74 | export interface DocNodeEnum extends DocNodeBase {
75 | kind: "enum";
76 | enumDef: EnumDef;
77 | }
78 |
79 | export interface DocNodeFunction extends DocNodeBase {
80 | kind: "function";
81 | functionDef: FunctionDef;
82 | }
83 |
84 | export interface DocNodeImport extends DocNodeBase {
85 | kind: "import";
86 | importDef: ImportDef;
87 | }
88 |
89 | export interface DocNodeInterface extends DocNodeBase {
90 | kind: "interface";
91 | interfaceDef: InterfaceDef;
92 | }
93 |
94 | export interface DocNodeNamespace extends DocNodeBase {
95 | kind: "namespace";
96 | namespaceDef: NamespaceDef;
97 | }
98 |
99 | export interface DocNodeTypeAlias extends DocNodeBase {
100 | kind: "typeAlias";
101 | typeAliasDef: TypeAliasDef;
102 | }
103 |
104 | export interface DocNodeVariable extends DocNodeBase {
105 | kind: "variable";
106 | variableDef: VariableDef;
107 | }
108 |
109 | export interface EnumDef {
110 | members: { name: string }[];
111 | }
112 |
113 | export interface FunctionDef {
114 | params: ParamDef[];
115 | returnType: TsTypeDef | null;
116 | isAsync: boolean;
117 | isGenerator: boolean;
118 | typeParams: TsTypeParamDef[];
119 | }
120 |
121 | export interface ImportDef {
122 | src: string;
123 | imported: string | null;
124 | }
125 |
126 | export interface InterfaceCallSignatureDef {
127 | location: Location;
128 | jsDoc: string | null;
129 | params: ParamDef[];
130 | tsType: TsTypeDef | null;
131 | typeParams: TsTypeParamDef[];
132 | }
133 |
134 | export interface InterfaceDef {
135 | extends: TsTypeDef[];
136 | methods: InterfaceMethodDef[];
137 | properties: InterfacePropertyDef[];
138 | callSignatures: InterfaceCallSignatureDef[];
139 | indexSignatures: InterfaceIndexSignatureDef[];
140 | typeParams: TsTypeParamDef[];
141 | }
142 |
143 | export interface InterfaceIndexSignatureDef {
144 | readonly: boolean;
145 | params: ParamDef[];
146 | tsType: TsTypeDef | null;
147 | }
148 |
149 | export interface InterfaceMethodDef {
150 | name: string;
151 | location: Location;
152 | jsDoc: string | null;
153 | optional: boolean;
154 | params: ParamDef[];
155 | returnType: TsTypeDef | null;
156 | typeParams: TsTypeParamDef[];
157 | }
158 |
159 | export interface InterfacePropertyDef {
160 | name: string;
161 | location: Location;
162 | jsDoc: string;
163 | params: ParamDef[];
164 | computed: boolean;
165 | optional: boolean;
166 | tsType: TsTypeDef | null;
167 | typeParams: TsTypeParamDef[];
168 | }
169 |
170 | export interface LiteralCallSignatureDef {
171 | params: ParamDef[];
172 | tsType: TsTypeDef | null;
173 | typeParams: TsTypeParamDef[];
174 | }
175 |
176 | export type LiteralDef = {
177 | kind: "number";
178 | number: number;
179 | } | {
180 | kind: "string";
181 | string: string;
182 | } | {
183 | kind: "boolean";
184 | boolean: boolean;
185 | };
186 |
187 | export interface LiteralIndexSignatureDef {
188 | readonly: boolean;
189 | params: ParamDef[];
190 | tsType: TsTypeDef | null;
191 | }
192 |
193 | export interface LiteralMethodDef {
194 | name: string;
195 | params: ParamDef[];
196 | returnType: TsTypeDef | null;
197 | typeParams: TsTypeParamDef[];
198 | }
199 |
200 | export interface LiteralPropertyDef {
201 | name: string;
202 | params: ParamDef[];
203 | computed: boolean;
204 | optional: boolean;
205 | tsType: TsTypeDef | null;
206 | typeParams: TsTypeParamDef[];
207 | }
208 |
209 | export interface Location {
210 | filename: string;
211 | line: number;
212 | col: number;
213 | }
214 |
215 | export type MethodKind = "method" | "getter" | "setter";
216 |
217 | export interface NamespaceDef {
218 | elements: DocNode[];
219 | }
220 |
221 | export type ObjectPatPropDef = {
222 | kind: "assign";
223 | key: string;
224 | value: string | null;
225 | } | {
226 | kind: "keyValue";
227 | key: string;
228 | value: ParamDef;
229 | } | {
230 | kind: "rest";
231 | arg: ParamDef;
232 | };
233 |
234 | export type ParamDef =
235 | | ParamDefArray
236 | | ParamDefAssign
237 | | ParamDefIdentifier
238 | | ParamDefObject
239 | | ParamDefRest;
240 |
241 | export interface ParamDefBase {
242 | tsType: TsTypeDef | null;
243 | }
244 |
245 | export interface ParamDefArray extends ParamDefBase {
246 | kind: "array";
247 | elements: (ParamDef | null)[];
248 | optional: boolean;
249 | }
250 |
251 | export interface ParamDefAssign extends ParamDefBase {
252 | kind: "assign";
253 | left: ParamDef;
254 | right: string;
255 | }
256 |
257 | export interface ParamDefIdentifier extends ParamDefBase {
258 | kind: "identifier";
259 | name: string;
260 | optional: boolean;
261 | }
262 |
263 | export interface ParamDefObject extends ParamDefBase {
264 | kind: "object";
265 | props: ObjectPatPropDef[];
266 | optional: boolean;
267 | }
268 |
269 | export interface ParamDefRest extends ParamDefBase {
270 | kind: "rest";
271 | arg: ParamDef;
272 | }
273 |
274 | export interface TypeAliasDef {
275 | tsType: TsTypeDef;
276 | typeParams: TsTypeParamDef[];
277 | }
278 |
279 | export type TsTypeDef = {
280 | kind: "array";
281 | array: TsTypeDef;
282 | } | {
283 | kind: "conditional";
284 | conditionalType: {
285 | checkType: TsTypeDef;
286 | extendsType: TsTypeDef;
287 | trueType: TsTypeDef;
288 | falseType: TsTypeDef;
289 | };
290 | } | {
291 | kind: "fnOrConstructor";
292 | fnOrConstructor: {
293 | constructor: boolean;
294 | tsType: TsTypeDef;
295 | params: ParamDef[];
296 | typeParams: TsTypeParamDef[];
297 | };
298 | } | {
299 | kind: "indexedAccess";
300 | indexedAccess: {
301 | readonly: boolean;
302 | objType: TsTypeDef;
303 | indexType: TsTypeDef;
304 | };
305 | } | {
306 | kind: "intersection";
307 | intersection: TsTypeDef[];
308 | } | {
309 | kind: "keyword";
310 | keyword: string;
311 | } | {
312 | kind: "literal";
313 | literal: LiteralDef;
314 | } | {
315 | kind: "optional";
316 | optional: TsTypeDef;
317 | } | {
318 | kind: "parenthesized";
319 | parenthesized: TsTypeDef;
320 | } | {
321 | kind: "rest";
322 | rest: TsTypeDef;
323 | } | {
324 | kind: "this";
325 | this: boolean;
326 | } | {
327 | kind: "tuple";
328 | tuple: TsTypeDef[];
329 | } | {
330 | kind: "typeLiteral";
331 | typeLiteral: TsTypeLiteralDef;
332 | } | {
333 | kind: "typeOperator";
334 | typeOperator: {
335 | operator: string;
336 | tsType: TsTypeDef;
337 | };
338 | } | {
339 | kind: "typeQuery";
340 | typeQuery: string;
341 | } | {
342 | kind: "typeRef";
343 | typeRef: {
344 | typeParams: TsTypeDef[] | null;
345 | typeName: string;
346 | };
347 | } | {
348 | kind: "union";
349 | union: TsTypeDef[];
350 | };
351 |
352 | export interface TsTypeLiteralDef {
353 | methods: LiteralMethodDef[];
354 | properties: LiteralPropertyDef[];
355 | callSignatures: LiteralCallSignatureDef[];
356 | indexSignatures: LiteralIndexSignatureDef[];
357 | }
358 |
359 | export interface TsTypeParamDef {
360 | name: string;
361 | constraint?: TsTypeDef;
362 | default?: TsTypeDef;
363 | }
364 |
365 | type VarDeclKind = "var" | "let" | "const";
366 |
367 | export interface VariableDef {
368 | tsType: TsTypeDef | null;
369 | kind: VarDeclKind;
370 | }
371 |
--------------------------------------------------------------------------------
/deno_info_json.ts:
--------------------------------------------------------------------------------
1 | export type Info = DenoInfo | FileInfo;
2 |
3 | export interface DenoInfo {
4 | denoDir: string;
5 | modulesCache: string;
6 | typescriptCache: string;
7 | }
8 |
9 | export interface FileDependency {
10 | size: number;
11 | deps: string[];
12 | }
13 |
14 | export interface FileInfo {
15 | local: string;
16 | fileType: "TypeScript" | "JavaScript";
17 | compiled: string | null;
18 | map: string | null;
19 | depCount: number;
20 | totalSize: number;
21 | files: Record
80 | ${htmlEscape(message)}
81 |
82 |