@xyd-js/uniform 0.1.0-xyd.8 → 0.1.0-xyd.98

package/src/plugins/pluginJsonView.ts

@@ -0,0 +1,54 @@
+import type { UniformPluginArgs, UniformPlugin } from "../index";
+import { Reference } from "../types";
+
+export interface pluginJsonViewOptions {
+}
+
+type pluginJsonViewOutput = {
+    jsonViews: string;
+}
+
+export function pluginJsonView(
+    options?: pluginJsonViewOptions
+): UniformPlugin<pluginJsonViewOutput> {
+
+    return function pluginJsonViewInner({
+        defer,
+    }: UniformPluginArgs) {
+        const jsonViews: string[] = [];
+
+        defer(() => ({
+            jsonViews
+        }))
+
+        return (ref: Reference) => {
+            // Build the output string manually to ensure exact format
+            const lines: string[] = [];
+            lines.push('{');
+            
+            ref.definitions.forEach(def => {
+                def.properties.forEach((prop, index) => {
+                    // Remove any quotes and trailing characters from the value
+                    const value = (prop.examples?.[0] || '').replace(/^"|"$|[^a-zA-Z0-9\s\-_.,:/@#=;+()]/g, '');
+                    const comment = prop.examples && prop.examples.length > 1 
+                        ? ` // or "${(prop.examples as string[])[1].replace(/^"|"$|[^a-zA-Z0-9\s\-_.,:/@#=;+()]/g, '')}"`
+                        : '';
+                    const isLast = index === def.properties.length - 1;
+                    // Add comma after the value but before the comment
+                    lines.push(`    "${prop.name}": "${value}"${isLast ? '' : ','}${comment}`);
+                });
+            });
+            
+            lines.push('}');
+            
+            jsonViews.push(lines.join('\n'));
+        }
+    }
+}
+
+// example usage:
+// const response = uniform([/* references */], {
+//     plugins: [pluginJsonView({
+//         
+//     })],
+// });

package/src/plugins/pluginNavigation.ts

@@ -0,0 +1,135 @@
+import path from 'node:path';
+
+import type { Sidebar, Metadata, MetadataMap, Settings, PageURL } from "@xyd-js/core";
+
+import type { UniformPluginArgs, UniformPlugin } from "../index";
+import { CodeBlockTab, Example, ExampleGroup, Reference } from "../types";
+
+const DEFAULT_VIRTUAL_FOLDER = ".xyd/.cache/.content" // TODO: share this + .xyd/.build/.content for build
+
+const DEFAULT_GROUP_NAME = "API Reference" // TODO: configurable
+
+type GroupMap = {
+    [key: string]: {
+        __groups: GroupMap
+        pages: Set<string>
+    }
+}
+
+export interface pluginNavigationOptions {
+    urlPrefix: string
+    defaultGroup?: string
+}
+
+type pluginNavigationOutput = {
+    pageFrontMatter: MetadataMap;
+    sidebar: Sidebar[];
+}
+
+export function pluginNavigation(
+    settings: Settings,
+    options: pluginNavigationOptions
+): UniformPlugin<pluginNavigationOutput> {
+    if (!options.urlPrefix) {
+        throw new Error("urlPrefix is required")
+    }
+
+    return function pluginNavigationInner({
+        defer,
+    }: UniformPluginArgs) {
+        const pageFrontMatter: MetadataMap = {}
+        const groupMaps: GroupMap = {}
+
+        defer(() => ({
+            pageFrontMatter,
+            sidebar: convertGroupMapsToSidebar(settings, groupMaps) as Sidebar[]
+        }))
+
+        return (ref: Reference) => {
+            const dataCtx = ref.context
+            const pagePath = path.join(options.urlPrefix, ref.canonical)
+
+            let group = dataCtx?.group || []
+            let title = ref.title
+
+            if (pageFrontMatter[pagePath]) {
+                console.error("(pluginNavigation): pageFrontMatter[pagePath] already exists", pagePath)
+            }
+
+            if (!group) {
+                group = [options.defaultGroup || DEFAULT_GROUP_NAME]
+            }
+
+            pageFrontMatter[pagePath] = {
+                title,
+            }
+
+            if (typeof group === "string") {
+                // TODO: seek nested group (it's not always from 0)
+                throw new Error("group as string is not supported yet")
+            }
+
+            group.reduce((groups: GroupMap, groupName: string, i: number) => {
+                if (!groups[groupName]) {
+                    groups[groupName] = {
+                        __groups: {},
+                        pages: new Set()
+                    }
+                }
+
+                if (i === group.length - 1) {
+                    groups[groupName].pages.add(pagePath)
+                }
+
+                return groups[groupName].__groups
+            }, groupMaps)
+        }
+    }
+}
+
+function convertGroupMapsToSidebar(settings: Settings, groupMaps: GroupMap): Sidebar[] {
+    const nav: Sidebar[] = []
+
+    Object.keys(groupMaps).map((groupName) => {
+        const current = groupMaps[groupName]
+
+        const pages: PageURL[] = []
+
+        current.pages.forEach((page: string) => {
+            if (settings?.engine?.uniform?.store) {
+                pages.push(page)
+                return
+            }
+            pages.push({
+                virtual: path.join(DEFAULT_VIRTUAL_FOLDER, page),
+                page: page,
+            })
+        })
+
+        if (Object.keys(current.__groups).length) {
+            const subNav: Sidebar = {
+                group: groupName,
+                pages: convertGroupMapsToSidebar(settings, current.__groups)
+            }
+
+            nav.push(subNav)
+
+            return
+        }
+
+        nav.push({
+            group: groupName,
+            pages,
+        })
+    })
+
+    return nav
+}
+
+// TODO: in the future xyd settings must be removed cuz uniform will be part of opendocs
+// example usage:
+// const response = uniform([/* references */], {
+//     plugins: [pluginNavigation({}, {
+//         urlPrefix: "/docs"
+//     })],
+// });

package/src/types.ts

@@ -1,54 +1,138 @@
-// TODO: concept only
-export enum ReferenceCategory {
-    // for React
-    COMPONENTS = "components",
-    HOOKS = "hooks",
-    // end for React
+import React from "react";
+import {HighlightedCode} from "codehike/code";
+
+// TODO: type, and category also as generic?
+export interface Reference<
+    C = ReferenceContext,
+    M extends DefinitionMeta = DefinitionMeta,
+    VM extends DefinitionVariantMeta = DefinitionVariantMeta
+> {
+    title: string;
+    description: string | React.ReactNode;
+    canonical: string;
 
-    // for API
-    REST = "rest",
-    GRAPHQL = "graphql",
-    // end for API
+    definitions: Definition<M, VM>[] // TODO: in the future from generic?
+    examples: ExampleRoot
 
-    // for code
-    FUNCTIONS = "functions",
-    //
+
+    category?: ReferenceCategory; // TODO: do we need that?
+
+    type?: ReferenceType; // TODO: do we need that?
+
+    context?: C;
+
+    /**
+     * TODO: !!!! BETTER !!!!
+     * @internal
+     */
+    __UNSAFE_selector?: (selector: string) => any;
 }
 
-// TODO: concept only
-export enum ReferenceType {
-    // for React
-    COMPONENT = "component",
-    HOOK = "hook",
-    // end for React
+export type DefinitionOpenAPIMeta = Meta<"contentType" | "required" | "definitionDescription">;
+export type DefinitionTypeDocMeta = Meta<"type">;
+export type DefinitionGraphqlMeta = Meta<"type" | "graphqlName">;
 
-    // for API
-    REST_HTTP_GET = "rest_get",
-    REST_HTTP_POST = "rest_post",
-    REST_HTTP_PUT = "rest_put",
-    REST_HTTP_PATCH = "rest_patch",
-    REST_HTTP_DELETE = "rest_delete",
-    // ---
-    GRAPHQL_QUERY = "graphql_query",
-    GRAPHQL_MUTATION = "graphql_mutation",
-    // end for API
+export type DefinitionMeta = DefinitionOpenAPIMeta | DefinitionTypeDocMeta | DefinitionGraphqlMeta
 
-    // for code
-    FUNCTION_JS = "function_js",
-    // end for code
+export type SymbolDef = {
+    id?: string | string[];
+
+    canonical?: string | string[];
 }
 
-export interface GraphQLReferenceContext {
+export interface Definition<
+    M extends DefinitionMeta = DefinitionMeta,
+    VM extends DefinitionVariantMeta = DefinitionVariantMeta
+> {
+    title: string;
+
+    properties: DefinitionProperty[];
+
+    rootProperty?: DefinitionProperty
+
+    variants?: DefinitionVariant<VM>[];
+
+    description?: string | React.ReactNode;
+
+    meta?: M[];
+
+    /**
+     * @internal
+     */
+    symbolDef?: SymbolDef;
+
+    /**
+     * @internal
+     */
+    id?: string;
+
+    /**
+     * @internal
+     */
+    type?: string;
 }
 
-// TODO: custom value?
-export interface OpenAPIReferenceContext {
-    method: string;
+export type DefinitionVariantOpenAPIMeta = Meta<"status" | "contentType" | "definitionDescription" | "required">;
+export type CommonDefinitionVariantMeta = Meta<"symbolName">;
+
+export type DefinitionVariantMeta = CommonDefinitionVariantMeta | DefinitionVariantOpenAPIMeta
+
+export interface DefinitionVariant<
+    M extends DefinitionVariantMeta = DefinitionVariantMeta
+> {
+    title: string;
+
+    properties: DefinitionProperty[];
+
+    rootProperty?: DefinitionProperty
+
+    description?: string | React.ReactNode;
+
+    symbolDef?: SymbolDef;
 
-    path: string;
+    meta?: M[];
 }
 
-export type ReferenceContext = GraphQLReferenceContext | OpenAPIReferenceContext;
+export interface Meta<T = string> {
+    name: T;
+
+    value?: unknown; // TODO: better type?
+}
+
+export type DefinitionPropertyMeta = Meta<"required" | "deprecated" | "internal" | "defaults" | "nullable" | "example" | "examples" | "minimum" | "maximum" | "enum-type"> // TODO: better solution than enum-type?
+
+export enum DEFINED_DEFINITION_PROPERTY_TYPE {
+    UNION = "$$union",
+
+    XOR = "$$xor",
+
+    ARRAY = "$$array",
+
+    ENUM = "$$enum",
+
+    // TYPE = "$$type", TODO: good idea?
+}
+
+export interface DefinitionProperty {
+    name: string;
+
+    type: string | DEFINED_DEFINITION_PROPERTY_TYPE
+
+    description: string | React.ReactNode;
+
+    // TODO: in the future more advanced examples?
+    examples?: string | string[];
+
+    symbolDef?: SymbolDef;
+
+    meta?: DefinitionPropertyMeta[];
+
+    context?: any // TODO: better type
+
+    properties?: DefinitionProperty[];
+
+    ofProperty?: DefinitionProperty;
+}
 
 export interface ExampleRoot {
     groups: ExampleGroup[];
@@ -72,66 +156,139 @@ export interface CodeBlock {
     tabs: CodeBlockTab[];
 }
 
-export interface GraphQLExampleContext {
-    schema?: any; // TODO:
-}
-
-export interface OpenAPIExampleContext {
-    status?: number;
-
-    content?: string;
-}
-
-export type ExampleContext = GraphQLExampleContext | OpenAPIExampleContext;
-
 export interface CodeBlockTab {
     // title of the tab e.g "JavaScript"
     title: string;
 
     // code in the tab e.g "console.log('Hello World')"
     code: string
-    
+
     // language of the code e.g "js"
     language: string;
 
     // context of the generation method e.g openapi or graphql
     context?: ExampleContext;
+
+    // TODO: highlighted code
+    highlighted?: HighlightedCode;
 }
 
-export interface Reference {
-    title: string;
-    description: string;
-    canonical: string;
+export type ExampleContext = GraphQLExampleContext | OpenAPIExampleContext;
 
-    definitions: Definition[]
-    examples: ExampleRoot
+// TODO: concept only
+export enum ReferenceCategory {
+    // for React
+    COMPONENTS = "components",
+    HOOKS = "hooks",
+    // end for React
 
-    category?: ReferenceCategory; // TODO: do we need that?
-    type?: ReferenceType; // TODO: do we need that?
-    context?: ReferenceContext;
+    // for API
+    REST = "rest",
+    GRAPHQL = "graphql",
+    // end for API
+
+    // for code
+    FUNCTIONS = "functions",
+    //
 }
 
-export interface Definition {
-    title: string;
+// TODO: concept only
+export enum ReferenceType {
+    // for React
+    COMPONENT = "component",
+    HOOK = "hook",
+    // end for React
 
-    properties: DefinitionProperty[];
+    // for API
+    // TODO: better type system for specific api typesl like gql or rest
+    REST_HTTP_GET = "rest_get",
+    REST_HTTP_POST = "rest_post",
+    REST_HTTP_PUT = "rest_put",
+    REST_HTTP_PATCH = "rest_patch",
+    REST_HTTP_DELETE = "rest_delete",
+    REST_HTTP_OPTIONS = "rest_options",
+    REST_HTTP_HEAD = "rest_head",
+    REST_HTTP_TRACE = "rest_trace",
 
+    REST_COMPONENT_SCHEMA = "rest_component_schema",
+    // ---
+    GRAPHQL_QUERY = "graphql_query",
+    GRAPHQL_MUTATION = "graphql_mutation",
+    GRAPHQL_SUBSCRIPTION = "graphql_subscription",
+
+    GRAPHQL_SCALAR = "graphql_scalar",
+    GRAPHQL_OBJECT = "graphql_object",
+    GRAPHQL_INTERFACE = "graphql_interface",
+    GRAPHQL_UNION = "graphql_union",
+    GRAPHQL_ENUM = "graphql_enum",
+    GRAPHQL_INPUT = "graphql_input",
+    // end for API
 
-    type?: string;
+    // for code
+    FUNCTION_JS = "function_js",
+    // end for code
+}
 
-    id?: string;
+export interface BaseReferenceContext {
+    group?: string[];
 
-    description?: string;
+    scopes?: string[];
 }
 
-export interface DefinitionProperty {
-    name: string;
+export interface GraphQLReferenceContext extends BaseReferenceContext {
+    /**
+     * @internal
+     */
+    graphqlTypeShort: string;
 
-    type: string;
+    graphqlName: string;
+}
 
-    description: string;
+// TODO: custom value?
+export interface OpenAPIReferenceContext extends BaseReferenceContext {
+    method?: string;
+
+    path?: string;
+
+    fullPath?: string;
+
+    componentSchema?: string
+}
+
+export type TypeDocReferenceContextMeta = Meta<"internal">
+
+// Add TypeDocReferenceContext to the union type
+export interface TypeDocReferenceContext extends BaseReferenceContext {
+    symbolId: string;
+    symbolName: string;
+    symbolKind: number;
+    packageName: string;
+    fileName: string;
+    fileFullPath: string;
+    line: number;
+    col: number;
+    signatureText: {
+        code: string;
+        lang: string;
+    };
+    sourcecode: {
+        code: string;
+        lang: string;
+    };
+    category?: string;
+    meta?: TypeDocReferenceContextMeta[]
+}
+
+export type ReferenceContext = GraphQLReferenceContext | OpenAPIReferenceContext | TypeDocReferenceContext
+
+export interface GraphQLExampleContext {
+    schema?: any; // TODO:
+}
+
+export interface OpenAPIExampleContext {
+    status?: number;
+
+    content?: string;
+}
 
-    context?: any // TODO: better type
 
-    properties?: DefinitionProperty[];
-}

package/tsconfig.json

@@ -1,5 +1,8 @@
 {
   "compilerOptions": {
+    "paths": {
+      "@xyd-js/core": ["../xyd-core/index.ts"],
+    },
     "target": "ES2020",
     "module": "ESNext",
     "moduleResolution": "node",
@@ -11,7 +14,7 @@
     "declaration": true,
     "declarationMap": true,
     "incremental": true,
-    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo"
+    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo",
   },
   "include": ["examples/basic-example/**/*.ts", "src/**/*.ts"],
   "exclude": ["node_modules", "dist"]

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.test.ts' ,'packages/ts/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: ['src/**/*.ts', 'packages/ts/**/*.ts'],
+      exclude: ['src/**/*.test.ts', 'src/**/*.d.ts', 'packages/ts/**/*.test.ts', 'packages/ts/**/*.d.ts']
+    }
+  }
+}); 

package/dist/types-CbDJSEtC.d.cts

@@ -1,81 +0,0 @@
-declare enum ReferenceCategory {
-    COMPONENTS = "components",
-    HOOKS = "hooks",
-    REST = "rest",
-    GRAPHQL = "graphql",
-    FUNCTIONS = "functions"
-}
-declare enum ReferenceType {
-    COMPONENT = "component",
-    HOOK = "hook",
-    REST_HTTP_GET = "rest_get",
-    REST_HTTP_POST = "rest_post",
-    REST_HTTP_PUT = "rest_put",
-    REST_HTTP_PATCH = "rest_patch",
-    REST_HTTP_DELETE = "rest_delete",
-    GRAPHQL_QUERY = "graphql_query",
-    GRAPHQL_MUTATION = "graphql_mutation",
-    FUNCTION_JS = "function_js"
-}
-interface GraphQLReferenceContext {
-}
-interface OpenAPIReferenceContext {
-    method: string;
-    path: string;
-}
-type ReferenceContext = GraphQLReferenceContext | OpenAPIReferenceContext;
-interface ExampleRoot {
-    groups: ExampleGroup[];
-}
-interface ExampleGroup {
-    description?: string;
-    examples: Example[];
-}
-interface Example {
-    description?: string;
-    codeblock: CodeBlock;
-}
-interface CodeBlock {
-    title?: string;
-    tabs: CodeBlockTab[];
-}
-interface GraphQLExampleContext {
-    schema?: any;
-}
-interface OpenAPIExampleContext {
-    status?: number;
-    content?: string;
-}
-type ExampleContext = GraphQLExampleContext | OpenAPIExampleContext;
-interface CodeBlockTab {
-    title: string;
-    code: string;
-    language: string;
-    context?: ExampleContext;
-}
-interface Reference {
-    title: string;
-    description: string;
-    canonical: string;
-    definitions: Definition[];
-    examples: ExampleRoot;
-    category?: ReferenceCategory;
-    type?: ReferenceType;
-    context?: ReferenceContext;
-}
-interface Definition {
-    title: string;
-    properties: DefinitionProperty[];
-    type?: string;
-    id?: string;
-    description?: string;
-}
-interface DefinitionProperty {
-    name: string;
-    type: string;
-    description: string;
-    context?: any;
-    properties?: DefinitionProperty[];
-}
-
-export { type CodeBlock as C, type Definition as D, type ExampleRoot as E, type GraphQLReferenceContext as G, type OpenAPIReferenceContext as O, type Reference as R, ReferenceCategory as a, ReferenceType as b, type ReferenceContext as c, type ExampleGroup as d, type Example as e, type GraphQLExampleContext as f, type OpenAPIExampleContext as g, type ExampleContext as h, type CodeBlockTab as i, type DefinitionProperty as j };