@limetech/kompendium 1.1.1

package/dist/search.ts

@@ -0,0 +1,197 @@
+import {
+    AliasDescription,
+    EnumDescription,
+    InterfaceDescription,
+    KompendiumData,
+    KompendiumDocument,
+    MenuItem,
+} from '../types';
+import Fuse from 'fuse.js';
+import {
+    JsonDocs,
+    JsonDocsComponent,
+    JsonDocsEvent,
+    JsonDocsProp,
+    JsonDocsTag,
+} from '@stencil/core/internal';
+
+export function createIndex(data: KompendiumData): any {
+    const docs = createDocs(data);
+    const keys: Fuse.FuseOptionKey[] = [
+        'tags',
+        'title',
+        'path',
+        'text',
+        'props.name',
+        'props.text',
+        'props.tags',
+        'props.type',
+        'events.name',
+        'events.text',
+        'events.tags',
+        'events.type',
+    ];
+
+    const index = Fuse.createIndex(keys, docs);
+
+    return {
+        documents: docs,
+        data: index.toJSON(),
+    };
+}
+
+function createDocs(data: KompendiumData): KompendiumDocument[] {
+    return Array.from(createDocuments(data.menu, data));
+}
+
+export function* createDocuments(
+    items: MenuItem[],
+    data: KompendiumData,
+): Generator<KompendiumDocument> {
+    for (const item of items) {
+        if (isIndexable(item)) {
+            const document = createDocument(item, data);
+            if (document) {
+                yield document;
+            }
+        }
+
+        if (item.children?.length) {
+            yield* createDocuments(item.children, data);
+        }
+    }
+}
+
+function isIndexable(item: MenuItem): boolean {
+    if (item.path?.match(/^\/component\/[\w-]+\/$/)) {
+        return true;
+    }
+
+    return !!item.children?.length;
+}
+
+function createDocument(
+    item: MenuItem,
+    data: KompendiumData,
+): KompendiumDocument {
+    if (item.path?.startsWith('/component/')) {
+        return createComponentDocument(item, data);
+    } else if (item.path?.startsWith('/type/')) {
+        return createTypeDocument(item, data);
+    }
+
+    return createGuideDocument(item, data);
+}
+
+function createComponentDocument(
+    item: MenuItem,
+    data: KompendiumData,
+): KompendiumDocument {
+    const tag = item.path.split('/')[2];
+    const component = data.docs.components.find((c) => c.tag === tag);
+    if (!component) {
+        return;
+    }
+
+    const examples = findExamples(component, data.docs);
+
+    return {
+        path: item.path,
+        title: item.title,
+        text: [component.docs, ...examples.map((e) => e.docs)],
+        props: component.props.map(createPropDocument),
+        events: component.events.map(createPropDocument),
+        tags: component.docsTags.map(createTagDocument),
+    };
+}
+
+function createTypeDocument(
+    item: MenuItem,
+    data: KompendiumData,
+): KompendiumDocument {
+    const type = data.types?.find((t) => t.name === item.title);
+
+    if (type?.type === 'interface') {
+        return createInterfaceDocument(item, type as InterfaceDescription);
+    } else if (type?.type === 'alias') {
+        return createAliasDocument(item, type as AliasDescription);
+    } else if (type?.type === 'enum') {
+        return createEnumDocument(item, type as EnumDescription);
+    }
+}
+
+function createGuideDocument(
+    item: MenuItem,
+    data: KompendiumData,
+): KompendiumDocument {
+    const guide = data.guides?.find((g) => g.data.path === item.path);
+
+    return {
+        path: item.path,
+        title: item.title,
+        text: guide?.content,
+    };
+}
+
+function createInterfaceDocument(
+    item: MenuItem,
+    type: InterfaceDescription,
+): KompendiumDocument {
+    return {
+        path: item.path,
+        title: item.title,
+        text: type.docs,
+        props: type.props.map(createPropDocument),
+        tags: type.docsTags?.map(createTagDocument),
+    };
+}
+
+function createAliasDocument(
+    item: MenuItem,
+    type: AliasDescription,
+): KompendiumDocument {
+    return {
+        path: item.path,
+        title: item.title,
+        text: type.docs,
+    };
+}
+
+// eslint-disable-next-line sonarjs/no-identical-functions
+function createEnumDocument(
+    item: MenuItem,
+    type: EnumDescription,
+): KompendiumDocument {
+    return {
+        path: item.path,
+        title: item.title,
+        text: type.docs,
+    };
+}
+
+function findExamples(component: JsonDocsComponent, docs: JsonDocs) {
+    return component.docsTags
+        .filter(isTag('exampleComponent'))
+        .map(findComponentByTag(docs));
+}
+
+const findComponentByTag = (docs: JsonDocs) => (tag: JsonDocsTag) => {
+    return docs.components.find((component) => component.tag === tag.text);
+};
+
+const isTag = (name: string) => (tag: JsonDocsTag) => {
+    return tag.name === name;
+};
+
+function createPropDocument(prop: JsonDocsProp | JsonDocsEvent) {
+    return {
+        name: (prop as JsonDocsProp).name || (prop as JsonDocsEvent).event,
+        tags: prop.docsTags?.map(createTagDocument),
+        text: prop.docs,
+        type: (prop as JsonDocsProp)?.type || (prop as JsonDocsEvent).detail,
+    };
+}
+
+function createTagDocument(tag: JsonDocsTag) {
+    return [tag.name, tag.text].join(' ');
+}

package/dist/source.ts

@@ -0,0 +1,129 @@
+import {
+    JsonDocs,
+    JsonDocsComponent,
+    JsonDocsTag,
+} from '@stencil/core/internal';
+import { readFile } from 'fs/promises';
+import { extname, join } from 'path';
+
+export interface JsonDocsSource {
+    filename: string;
+    type: 'tsx' | 'ts' | 'scss' | 'less' | 'css';
+    source: string;
+}
+
+export async function addSources(docs: JsonDocs): Promise<JsonDocs> {
+    const components = await Promise.all(
+        docs.components?.map(addComponentSources) || [],
+    );
+
+    return {
+        ...docs,
+        components: components,
+    };
+}
+
+export async function addComponentSources(
+    component: JsonDocsComponent,
+): Promise<any> {
+    const sources = await getSources(component);
+
+    return {
+        ...component,
+        sources: sources,
+    };
+}
+
+export async function getSources(
+    component: JsonDocsComponent,
+): Promise<JsonDocsSource[]> {
+    const source = await readFile(component.filePath, 'utf8');
+    const styleNames = getStyleFiles(source);
+    const styles = await Promise.all(
+        styleNames.map(getStyle(component.dirPath)),
+    );
+    const links = await getLinkedSourceFiles(component);
+
+    return [
+        {
+            filename: component.fileName,
+            type: 'tsx',
+            source: source,
+        },
+        ...styles,
+        ...links,
+    ];
+}
+
+export function getStyleFiles(source: string): string[] {
+    const result = [];
+    let regex = /@Component\((\{.+?\})\)/s;
+    let match = regex.exec(source);
+    const config = match && match[1];
+
+    if (!config) {
+        return result;
+    }
+
+    regex = /styleUrl:.+?['"](.+?)['"]/s;
+    match = regex.exec(config);
+
+    if (match && match[1]) {
+        result.push(match[1]);
+    }
+
+    return result;
+}
+
+const getStyle =
+    (path: string) =>
+    async (name: string): Promise<JsonDocsSource> => {
+        const source = await readFile([path, name].join('/'), 'utf8');
+
+        return {
+            filename: name,
+            type: 'scss',
+            source: source,
+        };
+    };
+
+async function getLinkedSourceFiles(
+    component: JsonDocsComponent,
+): Promise<JsonDocsSource[]> {
+    const deprecatedLinkTags = component.docsTags.filter(
+        (tag) => tag.name === 'link',
+    );
+    if (deprecatedLinkTags.length > 0) {
+        // eslint-disable-next-line no-console
+        console.warn(
+            'Using the @link tag to link source files for display alongside examples is deprecated. ' +
+                'Use @sourceFile instead.',
+        );
+    }
+
+    const linkTags = component.docsTags.filter(
+        (tag) => tag.name === 'sourceFile',
+    );
+    const backwardsCompatibleLinkTags = [...linkTags, ...deprecatedLinkTags];
+
+    return Promise.all<JsonDocsSource>(
+        backwardsCompatibleLinkTags.map(getLink(component)),
+    );
+}
+
+const getLink =
+    (component: JsonDocsComponent) =>
+    async (tag: JsonDocsTag): Promise<JsonDocsSource> => {
+        let source: string;
+        try {
+            source = await readFile(join(component.dirPath, tag.text), 'utf8');
+        } catch {
+            source = `File ${tag.text} not found`;
+        }
+
+        return {
+            filename: tag.text,
+            type: extname(tag.text).replace('.', '') as any,
+            source: source,
+        };
+    };