@ojiepermana/angular 22.0.1 → 22.0.29

package/generator/api/bin/src/emit/client.js

@@ -1,248 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitClient = emitClient;
-const template_1 = require("../render/template");
-/**
- * Emit the tiny runtime client primitives:
- *   - `api-configuration.ts`  — root-url config + provider
- *   - `base-service.ts`        — per-service rootUrl override
- *   - `strict-http-response.ts`— HttpResponse alias
- *   - `request-builder.ts`     — minimal (path / query / header / body / build)
- *   - `api.ts`                 — `Api` helper with invoke() / invoke$Response()
- *
- * These files are **static** — identical across specs — so we embed them as
- * template literals rather than parsing the IR. The only dynamic bits are the
- * banner comment and the configured default `rootUrl`.
- */
-function emitClient(target) {
-    const defaultRootUrl = target.rootUrl ?? '';
-    return [
-        { path: 'api-configuration.ts', content: (0, template_1.finalize)(apiConfigurationFile(target, defaultRootUrl)) },
-        { path: 'base-service.ts', content: (0, template_1.finalize)(baseServiceFile(target)) },
-        { path: 'strict-http-response.ts', content: (0, template_1.finalize)(strictResponseFile(target)) },
-        { path: 'request-builder.ts', content: (0, template_1.finalize)(requestBuilderFile(target)) },
-        { path: 'api.ts', content: (0, template_1.finalize)(apiFile(target)) },
-    ];
-}
-function apiConfigurationFile(target, rootUrl) {
-    return `${target.banner}
-
-import { Injectable, makeEnvironmentProviders, type EnvironmentProviders } from '@angular/core';
-
-@Injectable({ providedIn: 'root' })
-export class ApiConfiguration {
-  rootUrl: string = ${JSON.stringify(rootUrl)};
-}
-
-export function provideApiConfiguration(rootUrl: string): EnvironmentProviders {
-  return makeEnvironmentProviders([
-    {
-      provide: ApiConfiguration,
-      useFactory: () => {
-        const c = new ApiConfiguration();
-        c.rootUrl = rootUrl;
-        return c;
-      },
-    },
-  ]);
-}
-`;
-}
-function baseServiceFile(target) {
-    return `${target.banner}
-
-import { HttpClient } from '@angular/common/http';
-import { Injectable, inject } from '@angular/core';
-
-import { ApiConfiguration } from './api-configuration';
-
-@Injectable()
-export class BaseService {
-  protected readonly config = inject(ApiConfiguration);
-  protected readonly http = inject(HttpClient);
-
-  private _rootUrl?: string;
-
-  get rootUrl(): string {
-    return this._rootUrl ?? this.config.rootUrl;
-  }
-  set rootUrl(url: string) {
-    this._rootUrl = url;
-  }
-}
-`;
-}
-function strictResponseFile(target) {
-    return `${target.banner}
-
-import { HttpResponse } from '@angular/common/http';
-
-export type StrictHttpResponse<T> = HttpResponse<T> & { readonly body: T };
-`;
-}
-/**
- * Minimal request builder — intentionally drops the style/explode serializer
- * from ng-openapi-gen's output. Covers the 99% case: path templating, simple
- * query params (with array → repeated key), JSON body, and header params.
- */
-function requestBuilderFile(target) {
-    return `${target.banner}
-
-import {
-  HttpContext,
-  HttpHeaders,
-  HttpParams,
-  HttpRequest,
-} from '@angular/common/http';
-
-export interface BuildOptions {
-  accept?: string;
-  responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
-  reportUploadProgress?: boolean;
-  reportDownloadProgress?: boolean;
-  context?: HttpContext;
-}
-
-export class RequestBuilder {
-  private readonly _pathParams = new Map<string, unknown>();
-  private readonly _queryParams = new Map<string, unknown>();
-  private readonly _headerParams = new Map<string, unknown>();
-  private _body: unknown = undefined;
-  private _bodyContentType: string | undefined;
-
-  constructor(
-    public readonly rootUrl: string,
-    public readonly operationPath: string,
-    public readonly method: string,
-  ) {}
-
-  path(name: string, value: unknown): void {
-    this._pathParams.set(name, value);
-  }
-
-  query(name: string, value: unknown): void {
-    this._queryParams.set(name, value);
-  }
-
-  header(name: string, value: unknown): void {
-    this._headerParams.set(name, value);
-  }
-
-  body(value: unknown, contentType = 'application/json'): void {
-    if (value instanceof Blob) {
-      this._bodyContentType = value.type;
-    } else if (value instanceof FormData) {
-      // FormData sets its own Content-Type (with boundary) — leave it alone.
-      this._bodyContentType = undefined;
-    } else {
-      this._bodyContentType = contentType;
-    }
-    this._body = value;
-  }
-
-  build<T = unknown>(options: BuildOptions = {}): HttpRequest<T> {
-    let path = this.operationPath;
-    for (const [name, value] of this._pathParams) {
-      path = path.replace(
-        '{' + name + '}',
-        encodeURIComponent(value == null ? '' : String(value)),
-      );
-    }
-
-    let params = new HttpParams();
-    for (const [name, value] of this._queryParams) {
-      if (value === undefined || value === null) continue;
-      if (Array.isArray(value)) {
-        for (const v of value) {
-          if (v !== undefined && v !== null) params = params.append(name, String(v));
-        }
-      } else {
-        params = params.append(name, String(value));
-      }
-    }
-
-    let headers = new HttpHeaders();
-    if (options.accept) headers = headers.set('Accept', options.accept);
-    for (const [name, value] of this._headerParams) {
-      if (value === undefined || value === null) continue;
-      if (Array.isArray(value)) {
-        for (const v of value) headers = headers.append(name, String(v));
-      } else {
-        headers = headers.set(name, String(value));
-      }
-    }
-    if (this._bodyContentType) {
-      headers = headers.set('Content-Type', this._bodyContentType);
-    }
-
-    return new HttpRequest<T>(
-      this.method.toUpperCase(),
-      this.rootUrl + path,
-      this._body as T,
-      {
-        params,
-        headers,
-        responseType: options.responseType,
-        reportUploadProgress: options.reportUploadProgress,
-        reportDownloadProgress: options.reportDownloadProgress,
-        context: options.context,
-      },
-    );
-  }
-}
-`;
-}
-function apiFile(target) {
-    return `${target.banner}
-
-import { HttpClient, HttpContext, HttpResponse } from '@angular/common/http';
-import { Injectable, inject } from '@angular/core';
-import { Observable } from 'rxjs';
-import { filter, map } from 'rxjs/operators';
-
-import { ApiConfiguration } from './api-configuration';
-import { StrictHttpResponse } from './strict-http-response';
-
-export type ApiFn<P, R> = (
-  http: HttpClient,
-  rootUrl: string,
-  params: P,
-  context?: HttpContext,
-) => Observable<StrictHttpResponse<R>>;
-
-/**
- * Helper to invoke any tree-shakeable operation function directly.
- */
-@Injectable({ providedIn: 'root' })
-export class ${target.clientName} {
-  private readonly config = inject(ApiConfiguration);
-  private readonly http = inject(HttpClient);
-
-  private _rootUrl?: string;
-
-  get rootUrl(): string {
-    return this._rootUrl ?? this.config.rootUrl;
-  }
-  set rootUrl(url: string) {
-    this._rootUrl = url;
-  }
-
-  /** Invoke an operation function and stream the response body. */
-  invoke<P, R>(fn: ApiFn<P, R>, params: P, context?: HttpContext): Observable<R> {
-    return this.invoke$Response(fn, params, context).pipe(map((r) => r.body));
-  }
-
-  /** Invoke an operation function and stream the full HTTP response. */
-  invoke$Response<P, R>(
-    fn: ApiFn<P, R>,
-    params: P,
-    context?: HttpContext,
-  ): Observable<StrictHttpResponse<R>> {
-    return fn(this.http, this.rootUrl, params, context).pipe(
-      filter((r: unknown): r is HttpResponse<unknown> => r instanceof HttpResponse),
-      map((r) => r as StrictHttpResponse<R>),
-    );
-  }
-}
-`;
-}

package/generator/api/bin/src/emit/metadata.js

@@ -1,295 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitMetadata = emitMetadata;
-const template_1 = require("../render/template");
-/**
- * Emit frontend-friendly metadata:
- *   - `metadata-types.ts`            shared rule types
- *   - `permissions/<tag>.ts`         operation rules (per tag) + `index.ts`
- *   - `validators/<tag>.ts`          schema validation rules (per tag) + `index.ts`
- *   - `metadata.ts`                  aggregate export
- *   - `openapi-helpers.ts`           small helpers (`getRequiredPermissions`, etc)
- */
-function emitMetadata(ir, target) {
-    const files = [];
-    files.push({ path: 'metadata-types.ts', content: (0, template_1.finalize)(metadataTypesFile(target)) });
-    const opsByTag = groupOps(ir.operations);
-    for (const [tag, ops] of opsByTag) {
-        files.push({
-            path: `permissions/${(0, template_1.kebabCase)(tag)}.ts`,
-            content: (0, template_1.finalize)(permissionFile(tag, ops, target)),
-        });
-    }
-    const permTags = Array.from(opsByTag.keys());
-    files.push({
-        path: 'permissions/index.ts',
-        content: (0, template_1.finalize)(buildAggregateFile(target, permTags, 'ApiOperationRule', 'apiOperationRules', (t) => `${toCamel(t)}OperationRules`)),
-    });
-    const schemasByPrefix = groupSchemas(ir.schemas);
-    for (const [group, schemas] of schemasByPrefix) {
-        files.push({
-            path: `validators/${(0, template_1.kebabCase)(group)}.ts`,
-            content: (0, template_1.finalize)(validatorFile(group, schemas, target)),
-        });
-    }
-    const valGroups = Array.from(schemasByPrefix.keys());
-    files.push({
-        path: 'validators/index.ts',
-        content: (0, template_1.finalize)(buildAggregateFile(target, valGroups, 'ApiSchemaRule', 'apiValidationSchemas', (g) => `${toCamel(g)}ValidationSchemas`)),
-    });
-    files.push({ path: 'metadata.ts', content: (0, template_1.finalize)(metadataFile(target)) });
-    files.push({ path: 'openapi-helpers.ts', content: (0, template_1.finalize)(helpersFile(target)) });
-    return files;
-}
-/**
- * Emit a per-feature `index.ts` that re-exports each per-tag module plus a
- * single aggregated record (`apiOperationRules`, `apiValidationSchemas`).
- */
-function buildAggregateFile(target, groups, typeName, aggregateName, varNameFor) {
-    const reexports = groups.map((g) => `export { ${varNameFor(g)} } from './${(0, template_1.kebabCase)(g)}';`).join('\n');
-    const imports = groups.map((g) => `import { ${varNameFor(g)} } from './${(0, template_1.kebabCase)(g)}';`).join('\n');
-    const spreads = groups.map((g) => `  ...${varNameFor(g)},`).join('\n');
-    return `${target.banner}
-
-import type { ${typeName} } from '../metadata-types';
-${imports}
-
-${reexports}
-
-export const ${aggregateName}: Record<string, ${typeName}> = {
-${spreads}
-};
-`;
-}
-function metadataTypesFile(target) {
-    return `${target.banner}
-
-export interface ApiFieldRule {
-  required?: boolean;
-  type?: string;
-  format?: string;
-  description?: string;
-  nullable?: boolean;
-  minLength?: number;
-  maxLength?: number;
-  minimum?: number;
-  maximum?: number;
-  pattern?: string;
-  enumValues?: readonly (string | number)[];
-  ref?: string;
-  itemsRef?: string;
-  itemsType?: string;
-}
-
-export interface ApiSchemaRule {
-  required: readonly string[];
-  properties: Record<string, ApiFieldRule>;
-}
-
-export interface ApiOperationRule {
-  method: string;
-  path: string;
-  tags: readonly string[];
-  summary?: string;
-  description?: string;
-  requiredPermissions: readonly string[];
-  authorizationNotes: readonly string[];
-  securitySchemes: readonly string[];
-  pathParams: Record<string, ApiFieldRule>;
-  queryParams: Record<string, ApiFieldRule>;
-  bodySchema?: string;
-  responseSchemas: Record<string, string | undefined>;
-}
-`;
-}
-function permissionFile(tag, ops, target) {
-    const entries = ops
-        .slice()
-        .sort((a, b) => a.operationId.localeCompare(b.operationId))
-        .map((op) => renderOperationRule(op));
-    return `${target.banner}
-
-import type { ApiOperationRule } from '../metadata-types';
-
-export const ${toCamel(tag)}OperationRules: Record<string, ApiOperationRule> = {
-${entries.join(',\n')},
-};
-`;
-}
-function renderOperationRule(op) {
-    const pathParams = {};
-    const queryParams = {};
-    for (const p of op.params) {
-        const rule = trimRule(p.rule, p.required);
-        if (p.in === 'path')
-            pathParams[p.name] = rule;
-        else if (p.in === 'query')
-            queryParams[p.name] = rule;
-    }
-    const obj = {
-        method: op.method.toUpperCase(),
-        path: op.path,
-        tags: op.tags,
-        summary: op.summary,
-        description: op.description,
-        requiredPermissions: op.requiredPermissions,
-        authorizationNotes: op.authorizationNotes,
-        securitySchemes: op.securitySchemes,
-        pathParams,
-        queryParams,
-        bodySchema: op.bodySchemaRef,
-        responseSchemas: op.responses,
-    };
-    return `  ${JSON.stringify(op.operationId)}: ${toInlineJson(obj, 2)}`;
-}
-function validatorFile(group, schemas, target) {
-    const entries = schemas
-        .slice()
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .map((s) => renderSchemaRule(s));
-    return `${target.banner}
-
-import type { ApiSchemaRule } from '../metadata-types';
-
-export const ${toCamel(group)}ValidationSchemas: Record<string, ApiSchemaRule> = {
-${entries.join(',\n')},
-};
-`;
-}
-function renderSchemaRule(schema) {
-    const properties = {};
-    for (const [name, rule] of Object.entries(schema.properties)) {
-        properties[name] = trimRule(rule, rule.required === true);
-    }
-    const obj = {
-        required: schema.required,
-        properties,
-    };
-    return `  ${JSON.stringify(schema.name)}: ${toInlineJson(obj, 2)}`;
-}
-function metadataFile(target) {
-    return `${target.banner}
-
-export * from './metadata-types';
-export * from './permissions';
-export * from './validators';
-`;
-}
-function helpersFile(target) {
-    return `${target.banner}
-
-import { apiOperationRules, apiValidationSchemas } from './metadata';
-import type { ApiFieldRule, ApiOperationRule, ApiSchemaRule } from './metadata-types';
-
-export function getSchemaRule(schemaName: string): ApiSchemaRule | undefined {
-  return apiValidationSchemas[schemaName];
-}
-
-export function getFieldRule(schemaName: string, fieldName: string): ApiFieldRule | undefined {
-  return apiValidationSchemas[schemaName]?.properties[fieldName];
-}
-
-export function getOperationRule(operationId: string): ApiOperationRule | undefined {
-  return apiOperationRules[operationId];
-}
-
-export function getRequiredPermissions(operationId: string): readonly string[] {
-  return apiOperationRules[operationId]?.requiredPermissions ?? [];
-}
-
-export function hasRequiredPermissions(
-  operationId: string,
-  ownedPermissions: readonly string[],
-): boolean {
-  return getRequiredPermissions(operationId).every((p) => ownedPermissions.includes(p));
-}
-`;
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function groupOps(operations) {
-    const map = new Map();
-    for (const op of operations) {
-        const bucket = map.get(op.tag) ?? [];
-        bucket.push(op);
-        map.set(op.tag, bucket);
-    }
-    return map;
-}
-/**
- * Group schemas for validator output by a common prefix tag. We use a simple
- * heuristic: first PascalCase word of the schema name (e.g. `UserListResponse`
- * → `User`, `AuthTokenResponse` → `Auth`). Keeps file sizes small and mirrors
- * the reference layout.
- */
-function groupSchemas(schemas) {
-    const map = new Map();
-    for (const s of schemas) {
-        const prefix = detectSchemaGroup(s.name);
-        const bucket = map.get(prefix) ?? [];
-        bucket.push(s);
-        map.set(prefix, bucket);
-    }
-    return map;
-}
-function detectSchemaGroup(name) {
-    const match = name.match(/^([A-Z][a-z]+)/);
-    return match ? match[1] : 'Shared';
-}
-function trimRule(rule, required) {
-    const out = {};
-    if (required)
-        out.required = true;
-    else
-        out.required = false;
-    if (rule.type)
-        out.type = rule.type;
-    if (rule.format)
-        out.format = rule.format;
-    if (rule.description)
-        out.description = rule.description;
-    if (rule.nullable)
-        out.nullable = true;
-    if (typeof rule.minLength === 'number')
-        out.minLength = rule.minLength;
-    if (typeof rule.maxLength === 'number')
-        out.maxLength = rule.maxLength;
-    if (typeof rule.minimum === 'number')
-        out.minimum = rule.minimum;
-    if (typeof rule.maximum === 'number')
-        out.maximum = rule.maximum;
-    if (rule.pattern)
-        out.pattern = rule.pattern;
-    if (rule.enumValues && rule.enumValues.length)
-        out.enumValues = rule.enumValues;
-    if (rule.ref)
-        out.ref = rule.ref;
-    if (rule.itemsRef)
-        out.itemsRef = rule.itemsRef;
-    if (rule.itemsType)
-        out.itemsType = rule.itemsType;
-    return out;
-}
-/** Stable JSON output with stripped `undefined` values. */
-function toInlineJson(value, indent) {
-    const pretty = JSON.stringify(value, (_key, val) => (val === undefined ? undefined : val), 2);
-    if (!pretty)
-        return 'undefined';
-    return pretty
-        .split('\n')
-        .map((line, i) => (i === 0 ? line : ' '.repeat(indent) + line))
-        .join('\n');
-}
-function toCamel(input) {
-    const parts = String(input)
-        .replace(/[^a-zA-Z0-9]+/g, ' ')
-        .trim()
-        .split(/\s+/)
-        .filter(Boolean);
-    if (!parts.length)
-        return 'shared';
-    return parts
-        .map((w, i) => (i === 0 ? w[0].toLowerCase() + w.slice(1) : w[0].toUpperCase() + w.slice(1).toLowerCase()))
-        .join('');
-}

package/generator/api/bin/src/emit/models.js

@@ -1,106 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitModels = emitModels;
-exports.renderFieldType = renderFieldType;
-const template_1 = require("../render/template");
-/**
- * Emit one `interface` per schema into `models/<kebab>.ts` — type-only, no
- * runtime footprint.
- */
-function emitModels(ir, target) {
-    const files = [];
-    for (const schema of ir.schemas) {
-        const fileName = `${(0, template_1.kebabCase)(schema.name)}.ts`;
-        files.push({
-            path: `models/${fileName}`,
-            content: (0, template_1.finalize)(renderModel(schema, ir, target)),
-        });
-    }
-    return files;
-}
-function renderModel(schema, ir, target) {
-    const imports = collectModelImports(schema).filter((name) => name !== schema.name);
-    const importLines = imports.map((name) => `import type { ${name} } from './${(0, template_1.kebabCase)(name)}';`);
-    let body = '';
-    if (schema.enumValues) {
-        // Primitive enum alias.
-        body = `export type ${(0, template_1.pascalCase)(schema.name)} = ${schema.enumValues
-            .map((v) => (typeof v === 'string' ? `'${escapeSingle(v)}'` : String(v)))
-            .join(' | ')};`;
-    }
-    else if (schema.arrayItemRef || schema.arrayItemType) {
-        const itemType = schema.arrayItemRef ? (0, template_1.pascalCase)(schema.arrayItemRef) : tsPrimitive(schema.arrayItemType);
-        body = `export type ${(0, template_1.pascalCase)(schema.name)} = ${itemType}[];`;
-    }
-    else {
-        body = renderInterface(schema);
-    }
-    return [target.banner, '', ...importLines, importLines.length ? '' : '', body].join('\n');
-}
-function renderInterface(schema) {
-    const lines = [];
-    lines.push(`export interface ${(0, template_1.pascalCase)(schema.name)} {`);
-    for (const [propName, rule] of Object.entries(schema.properties)) {
-        const optional = rule.required ? '' : '?';
-        const type = renderFieldType(rule);
-        const safeName = /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(propName) ? propName : `'${propName}'`;
-        lines.push(`  ${safeName}${optional}: ${type};`);
-    }
-    lines.push(`}`);
-    return lines.join('\n');
-}
-function renderFieldType(rule) {
-    let base;
-    if (rule.ref) {
-        base = (0, template_1.pascalCase)(rule.ref);
-    }
-    else if (rule.type === 'array') {
-        const item = rule.itemsRef
-            ? (0, template_1.pascalCase)(rule.itemsRef)
-            : rule.enumValues
-                ? rule.enumValues.map((v) => (typeof v === 'string' ? `'${escapeSingle(v)}'` : String(v))).join(' | ')
-                : tsPrimitive(rule.itemsType);
-        base = rule.enumValues && !rule.itemsRef ? `(${item})[]` : `${item}[]`;
-    }
-    else if (rule.enumValues && rule.enumValues.length > 0) {
-        base = rule.enumValues.map((v) => (typeof v === 'string' ? `'${escapeSingle(v)}'` : String(v))).join(' | ');
-    }
-    else {
-        base = tsPrimitive(rule.type);
-    }
-    return rule.nullable ? `${base} | null` : base;
-}
-function tsPrimitive(type) {
-    switch (type) {
-        case 'string':
-            return 'string';
-        case 'integer':
-        case 'number':
-            return 'number';
-        case 'boolean':
-            return 'boolean';
-        case 'array':
-            return 'unknown[]';
-        case 'object':
-            return 'Record<string, unknown>';
-        case undefined:
-        case 'unknown':
-        default:
-            return 'unknown';
-    }
-}
-function escapeSingle(value) {
-    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
-}
-function collectModelImports(schema) {
-    const set = new Set();
-    if (schema.arrayItemRef)
-        set.add(schema.arrayItemRef);
-    for (const rule of Object.values(schema.properties)) {
-        if (rule.ref)
-            set.add(rule.ref);
-        if (rule.itemsRef)
-            set.add(rule.itemsRef);
-    }
-    return [...set].sort();
-}

package/generator/api/bin/src/emit/navigation.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.emitNavigation = emitNavigation;
-const template_1 = require("../render/template");
-/**
- * Emit `api.navigation.ts` exporting `NavigationItem[]` data that plugs
- * directly into `NavigationService.registerItems(...)` from
- * `@ojiepermana/angular/navigation`.
- */
-function emitNavigation(ir, target) {
-    return [
-        {
-            path: 'api.navigation.ts',
-            content: (0, template_1.finalize)(renderNavigation(ir.navigation, target)),
-        },
-    ];
-}
-function renderNavigation(nodes, target) {
-    return `${target.banner}
-
-import type { NavigationItem } from '@ojiepermana/angular/navigation/types';
-
-export const ApiNavigation: NavigationItem[] = ${stringifyNodes(nodes, 0, [])};
-`;
-}
-function stringifyNodes(nodes, depth, lineage) {
-    if (!nodes.length)
-        return '[]';
-    const pad = '  '.repeat(depth + 1);
-    const closePad = '  '.repeat(depth);
-    return `[\n${nodes
-        .map((node) => pad + stringifyNode(node, depth + 1, [...lineage, node.name]))
-        .join(',\n')},\n${closePad}]`;
-}
-function stringifyNode(node, depth, lineage) {
-    const hasChildren = node.children.length > 0;
-    const pad = '  '.repeat(depth + 1);
-    const closePad = '  '.repeat(depth);
-    const fields = [
-        `${pad}id: ${JSON.stringify(lineage.map(template_1.kebabCase).filter(Boolean).join('-'))}`,
-        `${pad}title: ${JSON.stringify(node.name)}`,
-        `${pad}type: ${JSON.stringify(resolveItemType(lineage.length - 1, hasChildren))}`,
-    ];
-    if (node.description)
-        fields.push(`${pad}subtitle: ${JSON.stringify(node.description)}`);
-    if (node.xIcon)
-        fields.push(`${pad}icon: ${JSON.stringify(node.xIcon)}`);
-    if (hasChildren)
-        fields.push(`${pad}children: ${stringifyNodes(node.children, depth + 1, lineage)}`);
-    return `{\n${fields.join(',\n')},\n${closePad}}`;
-}
-function resolveItemType(depth, hasChildren) {
-    if (!hasChildren)
-        return 'basic';
-    return depth === 0 ? 'group' : 'collapsable';
-}