@ojiepermana/angular 21.0.0 → 21.0.3

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

@@ -0,0 +1,246 @@
+"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';
+  reportProgress?: 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,
+        reportProgress: options.reportProgress,
+        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

@@ -0,0 +1,295 @@
+"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

@@ -0,0 +1,106 @@
+"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

@@ -0,0 +1,56 @@
+"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';
+
+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';
+}