@ojiepermana/angular 21.0.0 → 21.0.2

package/generator/guide/bin/schematics/init/index.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.init = init;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const FALLBACK_TEMPLATE = {
+    $schema: './node_modules/@ojiepermana/angular/generator/guide/schematics/build/schema.json',
+    sourceDir: './docs',
+    outputDir: './projects/demo/library/src/app/docs',
+    routeFile: 'doc.routes.ts',
+    componentPrefix: 'Doc',
+    componentStyle: 'none',
+    routeExportName: 'DOC_ROUTES',
+};
+function init(options = {}) {
+    return (tree, context) => {
+        const workspaceRoot = process.cwd();
+        const destRelative = options.path ?? 'config/guide.config.json';
+        const treePath = destRelative.startsWith('/') ? destRelative : `/${destRelative}`;
+        if (tree.exists(treePath) && !options.force) {
+            throw new Error(`${destRelative} already exists. Re-run with --force to overwrite.`);
+        }
+        const content = loadTemplate(workspaceRoot, destRelative);
+        const buffer = Buffer.from(content, 'utf8');
+        if (tree.exists(treePath)) {
+            tree.overwrite(treePath, buffer);
+            context.logger.info(`[guide:init] overwrote ${destRelative}`);
+        }
+        else {
+            tree.create(treePath, buffer);
+            context.logger.info(`[guide:init] created ${destRelative}`);
+        }
+        context.logger.info(`[guide:init] edit sourceDir / outputDir, then run \`${getNextCommand(workspaceRoot)}\`.`);
+    };
+}
+function loadTemplate(workspaceRoot, destRelative) {
+    const candidates = [
+        (0, node_path_1.resolve)(workspaceRoot, 'guide.config.example.json'),
+        (0, node_path_1.resolve)(__dirname, '../../../guide.config.example.json'),
+        (0, node_path_1.resolve)(workspaceRoot, 'projects/angular/generator/guide/guide.config.example.json'),
+    ];
+    for (const candidate of candidates) {
+        try {
+            const parsed = JSON.parse((0, node_fs_1.readFileSync)(candidate, 'utf8'));
+            parsed.$schema = resolveSchemaPath(workspaceRoot, destRelative);
+            return `${JSON.stringify(parsed, null, 2)}\n`;
+        }
+        catch {
+            // try next
+        }
+    }
+    return `${JSON.stringify({ ...FALLBACK_TEMPLATE, $schema: resolveSchemaPath(workspaceRoot, destRelative) }, null, 2)}\n`;
+}
+function resolveSchemaPath(workspaceRoot, destRelative) {
+    const prefix = relativePrefix(destRelative);
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(workspaceRoot, 'projects/angular/generator/guide/schematics/build/schema.json'))) {
+        return `${prefix}projects/angular/generator/guide/schematics/build/schema.json`;
+    }
+    return `${prefix}node_modules/@ojiepermana/angular/generator/guide/schematics/build/schema.json`;
+}
+function relativePrefix(destRelative) {
+    const depth = destRelative.replace(/^\/+/, '').split('/').length - 1;
+    return depth <= 0 ? './' : '../'.repeat(depth);
+}
+function getNextCommand(workspaceRoot) {
+    if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(workspaceRoot, 'projects/angular/collection.json'))) {
+        return 'bun run gen:guide';
+    }
+    return 'ng generate @ojiepermana/angular:guide';
+}

package/generator/guide/bin/src/config/loader.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+exports.resolveConfig = resolveConfig;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const VALID_STYLES = ['none', 'css', 'scss'];
+function loadConfig(configPath, workspaceRoot) {
+    const absolute = (0, node_path_1.isAbsolute)(configPath) ? configPath : (0, node_path_1.resolve)(workspaceRoot, configPath);
+    let raw;
+    try {
+        raw = (0, node_fs_1.readFileSync)(absolute, 'utf8');
+    }
+    catch (error) {
+        throw new Error(`[guide] Unable to read config at ${absolute}. Run \`bun run gen:guide:init\` to scaffold one. (${error.message})`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`[guide] Invalid JSON in ${absolute}: ${error.message}`);
+    }
+    return resolveConfig(parsed, absolute);
+}
+function resolveConfig(input, configPath) {
+    if (!input || typeof input !== 'object') {
+        throw new Error(`[guide] Config at ${configPath} must be a JSON object.`);
+    }
+    if (!input.sourceDir || typeof input.sourceDir !== 'string') {
+        throw new Error(`[guide] "sourceDir" is required in ${configPath}.`);
+    }
+    if (!input.outputDir || typeof input.outputDir !== 'string') {
+        throw new Error(`[guide] "outputDir" is required in ${configPath}.`);
+    }
+    const style = input.componentStyle ?? 'none';
+    if (!VALID_STYLES.includes(style)) {
+        throw new Error(`[guide] Invalid componentStyle "${style}". Expected one of ${VALID_STYLES.join(', ')}.`);
+    }
+    return {
+        sourceDir: input.sourceDir,
+        outputDir: input.outputDir,
+        routeFile: input.routeFile && input.routeFile.trim() ? input.routeFile : 'doc.routes.ts',
+        componentPrefix: input.componentPrefix && input.componentPrefix.trim() ? input.componentPrefix : 'Doc',
+        componentStyle: style,
+        routeExportName: input.routeExportName && /^[A-Za-z_][A-Za-z0-9_]*$/.test(input.routeExportName)
+            ? input.routeExportName
+            : 'DOC_ROUTES',
+    };
+}

package/generator/guide/bin/src/config/schema.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Public configuration shape for the `guide` schematic.
+ *
+ * The schematic reads `guide.config.json` at the workspace root and produces
+ * standalone Angular components plus a nested `Routes` file under `outputDir`.
+ *
+ * Node / Angular CLI utilities stay in the schematic package itself. This file
+ * is the only surface re-exported by the secondary entry point and therefore
+ * MUST stay free of Node-specific imports.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/generator/guide/bin/src/engine/component.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildComponent = buildComponent;
+const naming_1 = require("./naming");
+const render_1 = require("./render");
+function buildComponent(segments, frontmatter, body, config) {
+    const html = (0, render_1.renderMarkdown)(body);
+    const escaped = (0, render_1.escapeForTemplateLiteral)(html);
+    const className = (0, naming_1.componentClassName)(config.componentPrefix, segments);
+    const selector = (0, naming_1.componentSelector)(config.componentPrefix, segments);
+    const fileBase = (0, naming_1.componentFileBase)(segments);
+    const folderPath = segments.slice(0, -1).map(naming_1.toSlug).join('/');
+    const tsPath = joinPath(folderPath, `${fileBase}.component.ts`);
+    const { stylePath, styleRef, styleContent } = styleAssets(config.componentStyle, folderPath, fileBase);
+    const title = typeof frontmatter.title === 'string' && frontmatter.title.trim()
+        ? frontmatter.title.trim()
+        : humanizeTitle(segments);
+    const order = typeof frontmatter.order === 'number' ? frontmatter.order : null;
+    const pathOverride = typeof frontmatter.path === 'string' && frontmatter.path.trim() ? frontmatter.path.trim() : null;
+    const tsContent = renderComponentTs({
+        className,
+        selector,
+        html: escaped,
+        styleRef,
+    });
+    return {
+        className,
+        selector,
+        tsContent,
+        styleContent,
+        tsPath,
+        stylePath,
+        segments,
+        title,
+        order,
+        pathOverride,
+    };
+}
+function styleAssets(style, folder, fileBase) {
+    if (style === 'none') {
+        return { stylePath: null, styleRef: null, styleContent: null };
+    }
+    const ext = style === 'scss' ? 'scss' : 'css';
+    const stylePath = joinPath(folder, `${fileBase}.component.${ext}`);
+    return {
+        stylePath,
+        styleRef: `./${fileBase}.component.${ext}`,
+        styleContent: `:host { display: block; }\n`,
+    };
+}
+function renderComponentTs(opts) {
+    const styleLine = opts.styleRef ? `  styleUrl: '${opts.styleRef}',\n` : '';
+    return (`// Auto-generated by @ojiepermana/angular/generator/guide. Do not edit by hand.\n` +
+        `import { ChangeDetectionStrategy, Component } from '@angular/core';\n\n` +
+        `@Component({\n` +
+        `  selector: '${opts.selector}',\n` +
+        `  changeDetection: ChangeDetectionStrategy.OnPush,\n` +
+        styleLine +
+        `  template: \`${opts.html}\`,\n` +
+        `})\n` +
+        `export class ${opts.className} {}\n`);
+}
+function humanizeTitle(segments) {
+    const last = segments[segments.length - 1] ?? 'Untitled';
+    return last
+        .replace(/[-_]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/(^|\s)\S/g, (c) => c.toUpperCase());
+}
+function joinPath(folder, file) {
+    return folder ? `${folder}/${file}` : file;
+}

package/generator/guide/bin/src/engine/frontmatter.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMarkdown = parseMarkdown;
+const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
+function parseMarkdown(source) {
+    const match = source.match(FRONTMATTER_RE);
+    if (!match) {
+        return { frontmatter: {}, body: source };
+    }
+    const frontmatter = parseSimpleYaml(match[1]);
+    const body = source.slice(match[0].length);
+    return { frontmatter, body };
+}
+function parseSimpleYaml(yaml) {
+    const out = {};
+    for (const rawLine of yaml.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const idx = line.indexOf(':');
+        if (idx === -1)
+            continue;
+        const key = line.slice(0, idx).trim();
+        let value = line.slice(idx + 1).trim();
+        if (!key)
+            continue;
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (value === 'true')
+            out[key] = true;
+        else if (value === 'false')
+            out[key] = false;
+        else if (value !== '' && !Number.isNaN(Number(value)) && /^-?\d+(\.\d+)?$/.test(value)) {
+            out[key] = Number(value);
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}

package/generator/guide/bin/src/engine/index.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+const node_path_1 = require("node:path");
+const component_1 = require("./component");
+const frontmatter_1 = require("./frontmatter");
+const routes_1 = require("./routes");
+const walk_1 = require("./walk");
+function generate(config, workspaceRoot) {
+    const sourceAbs = resolveUnderRoot(config.sourceDir, workspaceRoot);
+    const outputAbs = resolveUnderRoot(config.outputDir, workspaceRoot);
+    const sources = (0, walk_1.collectMarkdown)(sourceAbs);
+    const components = sources.map((src) => {
+        const { frontmatter, body } = (0, frontmatter_1.parseMarkdown)(src.content);
+        return (0, component_1.buildComponent)(src.segments, frontmatter, body, config);
+    });
+    const files = [];
+    for (const comp of components) {
+        files.push({ path: joinWorkspace(workspaceRoot, outputAbs, comp.tsPath), content: comp.tsContent });
+        if (comp.stylePath && comp.styleContent !== null) {
+            files.push({ path: joinWorkspace(workspaceRoot, outputAbs, comp.stylePath), content: comp.styleContent });
+        }
+    }
+    files.push({
+        path: joinWorkspace(workspaceRoot, outputAbs, config.routeFile),
+        content: (0, routes_1.renderRoutes)(components, config),
+    });
+    return {
+        config,
+        outputDir: outputAbs,
+        files,
+        stats: { markdown: sources.length, components: components.length, files: files.length },
+    };
+}
+function resolveUnderRoot(p, workspaceRoot) {
+    return (0, node_path_1.isAbsolute)(p) ? p : (0, node_path_1.resolve)(workspaceRoot, p);
+}
+function joinWorkspace(workspaceRoot, outputAbs, rel) {
+    const abs = (0, node_path_1.resolve)(outputAbs, rel);
+    const normalized = abs.startsWith(workspaceRoot) ? abs.slice(workspaceRoot.length + 1) : abs;
+    return normalized.split(/[\\/]+/).join('/');
+}

package/generator/guide/bin/src/engine/naming.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSlug = toSlug;
+exports.toPascal = toPascal;
+exports.componentClassName = componentClassName;
+exports.componentFileBase = componentFileBase;
+exports.componentSelector = componentSelector;
+function toSlug(segment) {
+    return segment
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function toPascal(segment) {
+    return segment
+        .replace(/[^A-Za-z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .map((w) => (w.length === 0 ? w : w[0].toUpperCase() + w.slice(1).toLowerCase()))
+        .join('');
+}
+function componentClassName(prefix, segments) {
+    const base = segments.map(toPascal).join('');
+    return `${prefix}${base}Component`;
+}
+function componentFileBase(segments) {
+    const last = segments[segments.length - 1] ?? 'index';
+    return toSlug(last) || 'index';
+}
+function componentSelector(prefix, segments) {
+    const kebabPrefix = prefix
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/[^A-Za-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase() || 'doc';
+    const rest = segments.map(toSlug).filter(Boolean).join('-') || 'index';
+    return `${kebabPrefix}-${rest}`;
+}

package/generator/guide/bin/src/engine/render.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMarkdown = renderMarkdown;
+exports.escapeForTemplateLiteral = escapeForTemplateLiteral;
+const marked_1 = require("marked");
+/** Render Markdown (GFM) to HTML synchronously. */
+function renderMarkdown(body) {
+    marked_1.marked.setOptions({ gfm: true, breaks: false });
+    const html = marked_1.marked.parse(body, { async: false });
+    if (typeof html !== 'string') {
+        throw new Error('[guide] marked returned a non-string result; expected synchronous parse.');
+    }
+    return html.trim();
+}
+/** Escape backticks and `${` so HTML can be safely embedded in a TS template literal. */
+function escapeForTemplateLiteral(html) {
+    return html.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}

package/generator/guide/bin/src/engine/routes.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderRoutes = renderRoutes;
+const naming_1 = require("./naming");
+function renderRoutes(components, config) {
+    const root = { segment: '', children: new Map() };
+    for (const comp of components) {
+        insert(root, comp);
+    }
+    const body = serializeChildren(root, '  ');
+    const exportName = config.routeExportName;
+    return (`// Auto-generated by @ojiepermana/angular/generator/guide. Do not edit by hand.\n` +
+        `import type { Routes } from '@angular/router';\n\n` +
+        `export const ${exportName}: Routes = [\n` +
+        body +
+        `];\n`);
+}
+function insert(root, comp) {
+    const segments = routeSegments(comp);
+    let node = root;
+    for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        let next = node.children.get(seg);
+        if (!next) {
+            next = { segment: seg, children: new Map() };
+            node.children.set(seg, next);
+        }
+        node = next;
+    }
+    const leafSeg = segments[segments.length - 1];
+    let leaf = node.children.get(leafSeg);
+    if (!leaf) {
+        leaf = { segment: leafSeg, children: new Map() };
+        node.children.set(leafSeg, leaf);
+    }
+    if (leaf.leaf) {
+        throw new Error(`[guide] Route conflict: two markdown files resolve to the same path "${segments.join('/') || '<root>'}".`);
+    }
+    leaf.leaf = comp;
+}
+function routeSegments(comp) {
+    // file segments without extension; handle index.md as empty path at parent level
+    const segs = comp.segments.slice();
+    const last = segs[segs.length - 1] ?? 'index';
+    if (comp.pathOverride !== null) {
+        // Override replaces the leaf segment path (keeps parent folders).
+        segs[segs.length - 1] = comp.pathOverride === '' ? '' : comp.pathOverride;
+    }
+    else if (/^index$/i.test(last)) {
+        segs[segs.length - 1] = '';
+    }
+    else {
+        segs[segs.length - 1] = (0, naming_1.toSlug)(last);
+    }
+    // slugify folder segments
+    for (let i = 0; i < segs.length - 1; i++) {
+        segs[i] = (0, naming_1.toSlug)(segs[i]);
+    }
+    return segs;
+}
+function serializeChildren(node, indent) {
+    const children = [...node.children.values()].sort(compareNodes);
+    return children.map((c) => serializeNode(c, indent)).join('');
+}
+function compareNodes(a, b) {
+    const orderA = a.leaf?.order ?? Number.POSITIVE_INFINITY;
+    const orderB = b.leaf?.order ?? Number.POSITIVE_INFINITY;
+    if (orderA !== orderB)
+        return orderA - orderB;
+    return a.segment.localeCompare(b.segment);
+}
+function serializeNode(node, indent) {
+    const next = indent + '  ';
+    const lines = [];
+    lines.push(`${indent}{`);
+    lines.push(`${next}path: ${JSON.stringify(node.segment)},`);
+    if (node.leaf) {
+        const comp = node.leaf;
+        const importPath = importSpecifier(comp.tsPath);
+        lines.push(`${next}loadComponent: () => import(${JSON.stringify(importPath)}).then((m) => m.${comp.className}),`);
+        const data = routeData(comp);
+        if (data)
+            lines.push(`${next}data: ${data},`);
+    }
+    if (node.children.size > 0) {
+        lines.push(`${next}children: [`);
+        lines.push(serializeChildren(node, next + '  ').replace(/\n+$/, ''));
+        lines.push(`${next}],`);
+    }
+    lines.push(`${indent}},`);
+    return lines.join('\n') + '\n';
+}
+function routeData(comp) {
+    const parts = [];
+    if (comp.title)
+        parts.push(`title: ${JSON.stringify(comp.title)}`);
+    if (comp.order !== null)
+        parts.push(`order: ${comp.order}`);
+    if (parts.length === 0)
+        return null;
+    return `{ ${parts.join(', ')} }`;
+}
+function importSpecifier(tsPath) {
+    const noExt = tsPath.replace(/\.ts$/i, '');
+    return `./${noExt}`;
+}

package/generator/guide/bin/src/engine/walk.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectMarkdown = collectMarkdown;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+function collectMarkdown(sourceDir) {
+    const out = [];
+    walk(sourceDir, sourceDir, out);
+    return out.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+function walk(root, dir, out) {
+    const entries = (0, node_fs_1.readdirSync)(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const abs = (0, node_path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(root, abs, out);
+            continue;
+        }
+        if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md'))
+            continue;
+        const st = (0, node_fs_1.statSync)(abs);
+        if (!st.isFile())
+            continue;
+        const rel = (0, node_path_1.relative)(root, abs)
+            .split(/[\\/]+/)
+            .join('/');
+        const segments = rel.replace(/\.md$/i, '').split('/');
+        out.push({
+            absolutePath: abs,
+            relativePath: rel,
+            segments,
+            content: (0, node_fs_1.readFileSync)(abs, 'utf8'),
+        });
+    }
+}

package/generator/guide/guide.config.example.json

@@ -0,0 +1,9 @@
+{
+    "$schema": "./node_modules/@ojiepermana/angular/generator/guide/schematics/build/schema.json",
+    "sourceDir": "./docs",
+    "outputDir": "./projects/demo/library/src/app/docs",
+    "routeFile": "doc.routes.ts",
+    "componentPrefix": "Doc",
+    "componentStyle": "none",
+    "routeExportName": "DOC_ROUTES"
+}

package/generator/guide/schematics/build/schema.json

@@ -0,0 +1,14 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "GuideBuildSchema",
+    "title": "Guide · build",
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+        "config": {
+            "type": "string",
+            "description": "Path to the guide config file, relative to the workspace root.",
+            "default": "config/guide.config.json"
+        }
+    }
+}

package/generator/guide/schematics/init/schema.json

@@ -0,0 +1,19 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema",
+    "$id": "GuideInitSchema",
+    "title": "Guide · init",
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "Destination path for the generated guide.config.json, relative to the workspace root.",
+            "default": "config/guide.config.json"
+        },
+        "force": {
+            "type": "boolean",
+            "description": "Overwrite an existing guide.config.json.",
+            "default": false
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ojiepermana/angular",
-  "version": "21.0.0",
+  "version": "21.0.2",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/ojiepermana/angular.git"
@@ -38,14 +38,17 @@
     "d3-array": "^3.2.4",
     "d3-scale": "^4.0.2",
     "d3-shape": "^3.2.0",
+    "marked": "^16.0.0",
     "tailwind-merge": "^3.5.0",
-    "tslib": "^2.8.1"
+    "tslib": "^2.8.1",
+    "yaml": "^2.8.3"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "sideEffects": false,
+  "schematics": "./collection.json",
   "exports": {
     "./theme/styles": "./theme/styles/index.css",
     "./theme/styles/*": "./theme/styles/*",
@@ -65,6 +68,10 @@
       "types": "./types/ojiepermana-angular-component.d.ts",
       "default": "./fesm2022/ojiepermana-angular-component.mjs"
     },
+    "./generator/api": {
+      "types": "./types/ojiepermana-angular-generator-api.d.ts",
+      "default": "./fesm2022/ojiepermana-angular-generator-api.mjs"
+    },
     "./layout": {
       "types": "./types/ojiepermana-angular-layout.d.ts",
       "default": "./fesm2022/ojiepermana-angular-layout.mjs"
@@ -81,4 +88,4 @@
   "module": "fesm2022/ojiepermana-angular.mjs",
   "typings": "types/ojiepermana-angular.d.ts",
   "type": "module"
-}
+}

package/types/ojiepermana-angular-generator-api.d.ts

@@ -0,0 +1,85 @@
+/**
+ * Public config shape for the SDK generator.
+ *
+ * Users place an `sdk.config.json` at the workspace root describing one or more
+ * generation targets. All paths are resolved relative to the workspace root
+ * (i.e. the directory containing the config file).
+ */
+type SdkOutputMode = 'standalone' | 'library' | 'secondary-entrypoint';
+interface SdkFeatureFlags {
+    /** Emit `models/*.ts` (type-only DTO interfaces). Default `true`. */
+    models?: boolean;
+    /** Emit tree-shakeable operation functions in `fn/<tag>/*.ts`. Default `true`. */
+    operations?: boolean;
+    /** Emit grouped Injectable service classes per tag. Default `true`. */
+    services?: boolean;
+    /** Emit the runtime client primitives (ApiConfiguration, BaseService, etc). Default `true`. */
+    client?: boolean;
+    /** Emit operation rules + field validators + permission helpers. Default `true`. */
+    metadata?: boolean;
+    /** Emit navigation tree derived from tags (parent, x-icon). Default `false`. */
+    navigation?: boolean;
+}
+interface SdkTargetConfig {
+    /** Path to OpenAPI 3.x spec (YAML or JSON). Required. */
+    input: string;
+    /** Output directory (relative to workspace root). Required. */
+    output: string;
+    /** Output mode. Defaults to `"standalone"`. */
+    mode?: SdkOutputMode;
+    /** Optional human-readable name used for logs & the generated `Api` class. */
+    clientName?: string;
+    /** Package name used when `mode === "library"`. */
+    packageName?: string;
+    /** Package version used when `mode === "library"`. Defaults to `0.0.1`. */
+    packageVersion?: string;
+    /** Default rootUrl baked into ApiConfiguration. Defaults to the first server in the spec. */
+    rootUrl?: string;
+    /** Feature toggles. Every feature defaults to `true` except `navigation` (default `true` too). */
+    features?: SdkFeatureFlags;
+    /**
+     * When `true`, reorganize emitted files into one folder per domain (derived
+     * from OpenAPI tags). Models shared by multiple domains live in `shared/`,
+     * domain-owned models live inside each domain. Default `false` (flat layout).
+     */
+    splitByDomain?: boolean;
+    /**
+     * Granularity of `splitByDomain`. Only meaningful when `splitByDomain` is
+     * `true`. `'service'` (default) groups every tag under its root parent — one
+     * folder per backend service (e.g. all Role/Permission/... tags collapse into
+     * `access/`). `'tag'` emits one folder per leaf tag, nested under the parent
+     * chain (e.g. `storage/gcs/`, `storage/s3/`, `access/role/`).
+     */
+    splitDepth?: 'service' | 'tag';
+    /** Custom file banner. Defaults to a short auto-generated notice. */
+    banner?: string;
+}
+interface SdkConfig {
+    targets: SdkTargetConfig[];
+}
+interface ResolvedFeatureFlags {
+    models: boolean;
+    operations: boolean;
+    services: boolean;
+    client: boolean;
+    metadata: boolean;
+    navigation: boolean;
+}
+interface ResolvedSdkTarget {
+    input: string;
+    output: string;
+    mode: SdkOutputMode;
+    clientName: string;
+    packageName: string;
+    packageVersion: string;
+    rootUrl: string | undefined;
+    features: ResolvedFeatureFlags;
+    splitByDomain: boolean;
+    splitDepth: 'service' | 'tag';
+    banner: string;
+}
+declare function resolveTarget(raw: SdkTargetConfig): ResolvedSdkTarget;
+declare function resolveConfig(raw: unknown): ResolvedSdkTarget[];
+
+export { resolveConfig, resolveTarget };
+export type { ResolvedFeatureFlags, ResolvedSdkTarget, SdkConfig, SdkFeatureFlags, SdkOutputMode, SdkTargetConfig };