@ojiepermana/angular-sdk 22.0.44 → 22.0.46

package/src/parser/ir.js

@@ -0,0 +1,320 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildIR = buildIR;
+const HTTP_METHODS = ['get', 'post', 'put', 'patch', 'delete', 'head', 'options'];
+/**
+ * Build the Intermediate Representation from a bundled OpenAPI document.
+ *
+ * Expectations about input:
+ *  - `$ref` strings in the form `#/components/schemas/<Name>` (or parameters).
+ *  - OpenAPI 3.0.x / 3.1.x / 3.2.x (nullable via `type: ['string', 'null']` or
+ *    `nullable: true`).
+ */
+function buildIR(doc) {
+    const info = doc.info ?? {};
+    const servers = Array.isArray(doc.servers)
+        ? doc.servers.map((s) => ({ url: String(s.url ?? ''), description: s.description }))
+        : [];
+    const tags = Array.isArray(doc.tags)
+        ? doc.tags.map((t) => ({
+            name: String(t.name),
+            parent: t.parent,
+            kind: t.kind,
+            xIcon: t['x-icon'],
+            description: t.description,
+        }))
+        : [];
+    const schemas = buildSchemas(doc.components?.schemas);
+    const operations = buildOperations(doc.paths, doc.components?.parameters);
+    const security = buildSecuritySchemes(doc.components?.securitySchemes);
+    return {
+        title: String(info.title ?? 'API'),
+        version: String(info.version ?? '0.0.0'),
+        description: info.description,
+        servers,
+        tags,
+        navigation: buildNavigation(tags),
+        schemas,
+        operations,
+        security,
+    };
+}
+// ---------------------------------------------------------------------------
+// Schemas
+// ---------------------------------------------------------------------------
+function buildSchemas(rawSchemas) {
+    if (!rawSchemas)
+        return [];
+    const names = Object.keys(rawSchemas).sort();
+    return names.map((name) => buildSchema(name, rawSchemas[name]));
+}
+function buildSchema(name, raw) {
+    const required = Array.isArray(raw?.required) ? raw.required.slice() : [];
+    const properties = {};
+    // allOf — merge inline: fold each `properties` + required lists into the parent.
+    const parts = Array.isArray(raw?.allOf) ? raw.allOf : [];
+    const mergedProps = { ...(raw?.properties ?? {}) };
+    for (const part of parts) {
+        if (part?.properties)
+            Object.assign(mergedProps, part.properties);
+        if (Array.isArray(part?.required)) {
+            for (const r of part.required)
+                if (!required.includes(r))
+                    required.push(r);
+        }
+    }
+    for (const [propName, propSchema] of Object.entries(mergedProps)) {
+        properties[propName] = buildFieldRule(propSchema, required.includes(propName));
+    }
+    // Primitive enum schemas → emit as alias.
+    const primitiveType = resolvePrimitiveType(raw);
+    if (primitiveType && Array.isArray(raw?.enum)) {
+        return {
+            name,
+            description: raw?.description,
+            required: [],
+            properties: {},
+            enumValues: raw.enum,
+        };
+    }
+    // Array alias schemas.
+    if (resolvedTypeIs(raw, 'array') && raw?.items) {
+        const itemRef = refName(raw.items?.$ref);
+        const itemType = itemRef ? undefined : resolvePrimitiveType(raw.items);
+        return {
+            name,
+            description: raw?.description,
+            required: [],
+            properties: {},
+            arrayItemRef: itemRef ?? undefined,
+            arrayItemType: itemType ?? undefined,
+        };
+    }
+    return {
+        name,
+        description: raw?.description,
+        required,
+        properties,
+    };
+}
+function buildFieldRule(raw, required) {
+    const rule = { required };
+    // $ref → named reference.
+    const ref = refName(raw?.$ref);
+    if (ref) {
+        rule.ref = ref;
+        return rule;
+    }
+    // Array with items.
+    if (resolvedTypeIs(raw, 'array') && raw?.items) {
+        rule.type = 'array';
+        const itemsRef = refName(raw.items?.$ref);
+        if (itemsRef)
+            rule.itemsRef = itemsRef;
+        else
+            rule.itemsType = resolvePrimitiveType(raw.items) ?? 'unknown';
+        const itemEnum = raw.items?.enum;
+        if (Array.isArray(itemEnum))
+            rule.enumValues = itemEnum;
+        if (raw.description)
+            rule.description = raw.description;
+        rule.nullable = isNullable(raw);
+        return rule;
+    }
+    // Primitive / object.
+    rule.type = resolvePrimitiveType(raw) ?? 'unknown';
+    rule.nullable = isNullable(raw);
+    if (raw?.format)
+        rule.format = raw.format;
+    if (raw?.description)
+        rule.description = raw.description;
+    if (typeof raw?.minLength === 'number')
+        rule.minLength = raw.minLength;
+    if (typeof raw?.maxLength === 'number')
+        rule.maxLength = raw.maxLength;
+    if (typeof raw?.minimum === 'number')
+        rule.minimum = raw.minimum;
+    if (typeof raw?.maximum === 'number')
+        rule.maximum = raw.maximum;
+    if (typeof raw?.pattern === 'string')
+        rule.pattern = raw.pattern;
+    if (Array.isArray(raw?.enum))
+        rule.enumValues = raw.enum;
+    return rule;
+}
+function resolvePrimitiveType(raw) {
+    if (!raw)
+        return undefined;
+    const t = raw.type;
+    if (Array.isArray(t)) {
+        const nonNull = t.find((x) => x !== 'null');
+        return nonNull ?? undefined;
+    }
+    if (typeof t === 'string')
+        return t;
+    return undefined;
+}
+function resolvedTypeIs(raw, target) {
+    return resolvePrimitiveType(raw) === target;
+}
+function isNullable(raw) {
+    if (raw?.nullable === true)
+        return true;
+    const t = raw?.type;
+    if (Array.isArray(t) && t.includes('null'))
+        return true;
+    return false;
+}
+function refName(ref) {
+    if (typeof ref !== 'string')
+        return undefined;
+    const idx = ref.lastIndexOf('/');
+    return idx >= 0 ? ref.slice(idx + 1) : ref;
+}
+// ---------------------------------------------------------------------------
+// Operations
+// ---------------------------------------------------------------------------
+function buildOperations(paths, sharedParams) {
+    if (!paths)
+        return [];
+    const operations = [];
+    for (const [pathKey, pathItem] of Object.entries(paths)) {
+        if (!pathItem || typeof pathItem !== 'object')
+            continue;
+        const pathLevelParams = Array.isArray(pathItem.parameters) ? pathItem.parameters : [];
+        for (const method of HTTP_METHODS) {
+            const op = pathItem[method];
+            if (!op)
+                continue;
+            operations.push(buildOperation(pathKey, method, op, pathLevelParams, sharedParams));
+        }
+    }
+    return operations.sort((a, b) => a.operationId.localeCompare(b.operationId));
+}
+function buildOperation(path, method, op, pathLevelParams, sharedParams) {
+    const tags = Array.isArray(op.tags) && op.tags.length ? op.tags.map(String) : ['Default'];
+    const params = mergeParams(pathLevelParams, op.parameters, sharedParams);
+    const body = op.requestBody;
+    const bodySchemaRef = refName(body?.content?.['application/json']?.schema?.$ref) ?? refName(body?.$ref) ?? undefined;
+    const responses = {};
+    let successStatus;
+    let successRef;
+    for (const [status, resp] of Object.entries(op.responses ?? {})) {
+        const r = resp;
+        const ref = refName(r?.content?.['application/json']?.schema?.$ref) ?? refName(r?.$ref) ?? undefined;
+        responses[status] = ref;
+        if (!successStatus && status.startsWith('2')) {
+            successStatus = status;
+            successRef = ref;
+        }
+    }
+    const securitySchemes = [];
+    if (Array.isArray(op.security)) {
+        for (const s of op.security) {
+            if (s && typeof s === 'object') {
+                for (const key of Object.keys(s)) {
+                    if (!securitySchemes.includes(key))
+                        securitySchemes.push(key);
+                }
+            }
+        }
+    }
+    const requiredPermissions = Array.isArray(op['x-required-permissions'])
+        ? op['x-required-permissions'].map(String)
+        : [];
+    const authorizationNotes = Array.isArray(op['x-authorization-notes'])
+        ? op['x-authorization-notes'].map(String)
+        : [];
+    const operationId = op.operationId ?? synthesizeOperationId(method, path);
+    return {
+        operationId,
+        method,
+        path,
+        tag: tags[0],
+        tags,
+        summary: op.summary,
+        description: op.description,
+        params,
+        bodySchemaRef,
+        bodyRequired: body?.required === true,
+        responses,
+        successStatus,
+        successRef,
+        securitySchemes,
+        requiredPermissions,
+        authorizationNotes,
+    };
+}
+function mergeParams(pathLevelParams, opParams, sharedParams) {
+    const all = [...(pathLevelParams ?? []), ...(opParams ?? [])];
+    const seen = new Set();
+    const out = [];
+    for (const raw of all) {
+        const resolved = resolveParamRef(raw, sharedParams);
+        if (!resolved?.name || !resolved?.in)
+            continue;
+        const key = `${resolved.in}:${resolved.name}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        const loc = resolved.in === 'path' || resolved.in === 'query' || resolved.in === 'header' ? resolved.in : 'query';
+        const rule = buildFieldRule(resolved.schema ?? {}, !!resolved.required);
+        out.push({
+            name: resolved.name,
+            in: loc,
+            required: !!resolved.required,
+            rule,
+        });
+    }
+    return out;
+}
+function resolveParamRef(raw, sharedParams) {
+    if (!raw)
+        return raw;
+    if (typeof raw.$ref !== 'string')
+        return raw;
+    const name = refName(raw.$ref);
+    if (!name || !sharedParams)
+        return raw;
+    return sharedParams[name] ?? raw;
+}
+function synthesizeOperationId(method, path) {
+    const cleaned = path
+        .replace(/\/+/g, '/')
+        .split('/')
+        .filter(Boolean)
+        .map((seg) => seg.replace(/^\{/, 'by-').replace(/\}$/, ''))
+        .join('-');
+    return `${method}-${cleaned || 'root'}`;
+}
+// ---------------------------------------------------------------------------
+// Security & navigation
+// ---------------------------------------------------------------------------
+function buildSecuritySchemes(raw) {
+    if (!raw)
+        return [];
+    return Object.entries(raw).map(([name, s]) => ({
+        name,
+        type: String(s.type ?? 'unknown'),
+        scheme: s.scheme,
+        bearerFormat: s.bearerFormat,
+        in: s.in,
+    }));
+}
+function buildNavigation(tags) {
+    const byName = new Map();
+    for (const t of tags) {
+        byName.set(t.name, { name: t.name, xIcon: t.xIcon, description: t.description, children: [] });
+    }
+    const roots = [];
+    for (const t of tags) {
+        const node = byName.get(t.name);
+        if (t.parent && byName.has(t.parent)) {
+            byName.get(t.parent).children.push(node);
+        }
+        else {
+            roots.push(node);
+        }
+    }
+    return roots;
+}

package/src/parser/types.js

@@ -0,0 +1,7 @@
+"use strict";
+/**
+ * Intermediate Representation (IR) that emitters consume. Keeping this thin +
+ * plain-object makes emitters trivial to unit test without pulling in an OpenAPI
+ * parser in the test path.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/render/template.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * Tiny rendering helpers. We use template literals + small utilities rather
+ * than a template engine to keep the generator dependency-free and the
+ * emitter output predictable.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.kebabCase = kebabCase;
+exports.pascalCase = pascalCase;
+exports.camelCase = camelCase;
+exports.finalize = finalize;
+exports.comment = comment;
+exports.joinBlocks = joinBlocks;
+/** kebab-case (preserving digits) — matches the naming style in `old/api/`. */
+function kebabCase(input) {
+    return String(input)
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+        .replace(/[^a-zA-Z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .toLowerCase();
+}
+/** PascalCase — used for class/interface names when sanitizing tags. */
+function pascalCase(input) {
+    return String(input)
+        .replace(/[^a-zA-Z0-9]+/g, ' ')
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join('');
+}
+/** camelCase — used for variable / method / fn names. */
+function camelCase(input) {
+    const pc = pascalCase(input);
+    return pc ? pc[0].toLowerCase() + pc.slice(1) : '';
+}
+/** Trim trailing whitespace on every line and ensure a single trailing newline. */
+function finalize(text) {
+    const trimmed = text
+        .split('\n')
+        .map((line) => line.replace(/\s+$/g, ''))
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/^\s*\n/, '');
+    return trimmed.endsWith('\n') ? trimmed : trimmed + '\n';
+}
+/** Render an indented block-comment (1-line friendly). */
+function comment(text) {
+    if (!text)
+        return '';
+    const safe = text.replace(/\*\//g, '*\\/');
+    return `/** ${safe} */`;
+}
+/** Join non-empty blocks with a blank line between them. */
+function joinBlocks(blocks) {
+    return blocks.filter(Boolean).join('\n\n');
+}

package/src/writer/index.js

@@ -0,0 +1,278 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeStandalone = writeStandalone;
+exports.writeLibrary = writeLibrary;
+exports.writeSecondaryEntrypoint = writeSecondaryEntrypoint;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const template_1 = require("../render/template");
+const ROOT_ENTRYPOINT = '';
+const VIRTUAL_ROOT = '/__sdk__';
+/**
+ * No-op writer for the standalone mode — returns emitted files unchanged. Kept
+ * as a named function so modes are composable from a single switch at the
+ * engine layer.
+ */
+function writeStandalone(files) {
+    return files;
+}
+/**
+ * Library mode: add `ng-package.json`, `package.json`, and a top-level README
+ * so the `output` folder can be built with ng-packagr directly.
+ */
+function writeLibrary(files, ir, target, workspaceRoot, outputDir) {
+    const normalizedFiles = rewriteCrossEntrypointImports(files, target, workspaceRoot, outputDir);
+    const ngPackage = {
+        $schema: toPosixPath((0, node_path_1.relative)(outputDir, (0, node_path_1.resolve)(workspaceRoot, 'node_modules/ng-packagr/ng-package.schema.json'))),
+        dest: resolveLibraryDestPath(workspaceRoot, outputDir),
+        lib: { entryFile: 'public-api.ts' },
+    };
+    const pkg = {
+        name: target.packageName,
+        version: target.packageVersion,
+        description: `Generated SDK for ${ir.title} ${ir.version}`,
+        peerDependencies: {
+            '@angular/common': '>=22.0.0',
+            '@angular/core': '>=22.0.0',
+            rxjs: '>=7.8.0',
+        },
+        sideEffects: false,
+    };
+    return [
+        ...normalizedFiles,
+        createNgPackageFile('ng-package.json', ngPackage),
+        ...createNestedEntrypointNgPackages(normalizedFiles),
+        {
+            path: 'package.json',
+            content: (0, template_1.finalize)(JSON.stringify(pkg, null, 2)),
+        },
+        ...createLibraryTsConfigFiles(workspaceRoot, outputDir),
+        {
+            path: 'README.md',
+            content: (0, template_1.finalize)(`# ${target.packageName}\n\nGenerated SDK for **${ir.title}** v${ir.version}.\n\nThis folder was generated by the local SDK generator. Do not edit by hand.\n`),
+        },
+    ];
+}
+/**
+ * Secondary-entrypoint mode: same file set as standalone, plus a minimal
+ * `ng-package.json` pointing at `public-api.ts`. Meant to live **inside** an
+ * existing library (e.g. `projects/angular/sdk-api/`) so ng-packagr picks it
+ * up automatically as a secondary entrypoint of the parent library.
+ */
+function writeSecondaryEntrypoint(files, _ir, target, workspaceRoot, outputDir) {
+    const normalizedFiles = rewriteCrossEntrypointImports(files, target, workspaceRoot, outputDir);
+    const ngPackage = {
+        lib: { entryFile: 'public-api.ts' },
+    };
+    return [
+        ...normalizedFiles,
+        createNgPackageFile('ng-package.json', ngPackage),
+        ...createNestedEntrypointNgPackages(normalizedFiles),
+    ];
+}
+function rewriteCrossEntrypointImports(files, target, workspaceRoot, outputDir) {
+    const entrypointDirs = collectEntrypointDirs(files);
+    if (entrypointDirs.length <= 1) {
+        return [...files];
+    }
+    const packageImportBase = resolvePackageImportBase(target, workspaceRoot, outputDir);
+    if (!packageImportBase) {
+        return [...files];
+    }
+    const knownFiles = new Set(files.map((file) => file.path));
+    return files.map((file) => {
+        const owner = findEntrypointOwner(file.path, entrypointDirs);
+        if (owner === ROOT_ENTRYPOINT) {
+            return file;
+        }
+        return {
+            ...file,
+            content: file.content.replace(/(from\s+['"])([^'"]+)(['"])/g, (_match, prefix, spec, suffix) => {
+                const nextSpec = rewriteModuleSpecifier(spec, file.path, owner, entrypointDirs, knownFiles, packageImportBase);
+                return `${prefix}${nextSpec}${suffix}`;
+            }),
+        };
+    });
+}
+function rewriteModuleSpecifier(specifier, currentPath, currentOwner, entrypointDirs, knownFiles, packageImportBase) {
+    if (!specifier.startsWith('./') && !specifier.startsWith('../')) {
+        return specifier;
+    }
+    const targetPath = resolveVirtualFilePath(currentPath, specifier, knownFiles);
+    if (!targetPath) {
+        return specifier;
+    }
+    const targetOwner = findEntrypointOwner(targetPath, entrypointDirs);
+    if (targetOwner === currentOwner) {
+        return specifier;
+    }
+    return buildEntrypointImport(packageImportBase, targetOwner);
+}
+function resolveVirtualFilePath(currentPath, specifier, knownFiles) {
+    const currentAbs = node_path_1.posix.join(VIRTUAL_ROOT, currentPath);
+    const resolved = node_path_1.posix.normalize(node_path_1.posix.join((0, node_path_1.dirname)(currentAbs), specifier));
+    const candidates = [`${resolved}.ts`, `${resolved}/index.ts`, `${resolved}/public-api.ts`, resolved];
+    for (const candidate of candidates) {
+        if (!candidate.startsWith(`${VIRTUAL_ROOT}/`)) {
+            continue;
+        }
+        const relativePath = candidate.slice(VIRTUAL_ROOT.length + 1);
+        if (knownFiles.has(relativePath)) {
+            return relativePath;
+        }
+    }
+    return undefined;
+}
+function resolvePackageImportBase(target, workspaceRoot, outputDir) {
+    if (target.mode === 'library') {
+        return target.packageName;
+    }
+    if (target.mode !== 'secondary-entrypoint') {
+        return '';
+    }
+    return inferSecondaryEntrypointPackageName(workspaceRoot, outputDir, target.packageName);
+}
+function inferSecondaryEntrypointPackageName(workspaceRoot, outputDir, fallback) {
+    let currentDir = outputDir;
+    let nearestPackageDir;
+    let nearestPackagrDir;
+    while (isWithinWorkspace(currentDir, workspaceRoot)) {
+        const packageJsonPath = (0, node_path_1.resolve)(currentDir, 'package.json');
+        if ((0, node_fs_1.existsSync)(packageJsonPath)) {
+            nearestPackageDir ??= currentDir;
+            if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(currentDir, 'ng-package.json'))) {
+                nearestPackagrDir = currentDir;
+                break;
+            }
+        }
+        if (currentDir === workspaceRoot) {
+            break;
+        }
+        const parentDir = (0, node_path_1.dirname)(currentDir);
+        if (parentDir === currentDir) {
+            break;
+        }
+        currentDir = parentDir;
+    }
+    const packageDir = nearestPackagrDir ?? nearestPackageDir;
+    if (!packageDir) {
+        return fallback;
+    }
+    const packageName = readPackageName(packageDir);
+    if (!packageName) {
+        return fallback;
+    }
+    const relativeOutput = toPosixPath((0, node_path_1.relative)(packageDir, outputDir)).replace(/^\.\//, '');
+    if (!relativeOutput || relativeOutput === '.') {
+        return packageName;
+    }
+    return `${packageName}/${relativeOutput}`;
+}
+function readPackageName(packageDir) {
+    const packageJsonPath = (0, node_path_1.resolve)(packageDir, 'package.json');
+    if (!(0, node_fs_1.existsSync)(packageJsonPath)) {
+        return undefined;
+    }
+    const raw = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, 'utf8'));
+    return typeof raw.name === 'string' && raw.name.length > 0 ? raw.name : undefined;
+}
+function isWithinWorkspace(candidate, workspaceRoot) {
+    const rel = (0, node_path_1.relative)(workspaceRoot, candidate);
+    return rel === '' || (!rel.startsWith('..') && !(0, node_path_1.isAbsolute)(rel));
+}
+function collectEntrypointDirs(files) {
+    const dirs = new Set();
+    for (const file of files) {
+        if (file.path === 'public-api.ts') {
+            dirs.add(ROOT_ENTRYPOINT);
+            continue;
+        }
+        if (!file.path.endsWith('/public-api.ts')) {
+            continue;
+        }
+        dirs.add(file.path.slice(0, -'/public-api.ts'.length));
+    }
+    return [...dirs].sort((left, right) => right.length - left.length || left.localeCompare(right));
+}
+function findEntrypointOwner(filePath, entrypointDirs) {
+    for (const entrypointDir of entrypointDirs) {
+        if (entrypointDir === ROOT_ENTRYPOINT) {
+            continue;
+        }
+        if (filePath === `${entrypointDir}/public-api.ts` || filePath.startsWith(`${entrypointDir}/`)) {
+            return entrypointDir;
+        }
+    }
+    return ROOT_ENTRYPOINT;
+}
+function buildEntrypointImport(packageImportBase, entrypointDir) {
+    return entrypointDir ? `${packageImportBase}/${entrypointDir}` : packageImportBase;
+}
+function createNestedEntrypointNgPackages(files) {
+    return collectSecondaryEntrypointDirs(files).map((dir) => createNgPackageFile(`${dir}/ng-package.json`, {
+        lib: { entryFile: 'public-api.ts' },
+    }));
+}
+function collectSecondaryEntrypointDirs(files) {
+    const dirs = new Set();
+    for (const file of files) {
+        if (!file.path.endsWith('/public-api.ts')) {
+            continue;
+        }
+        dirs.add(file.path.slice(0, -'/public-api.ts'.length));
+    }
+    return [...dirs].sort();
+}
+function resolveLibraryDestPath(workspaceRoot, outputDir) {
+    const outputFolderName = (0, node_path_1.basename)(outputDir) || 'sdk';
+    return toPosixPath((0, node_path_1.relative)(outputDir, (0, node_path_1.resolve)(workspaceRoot, 'dist', outputFolderName)));
+}
+function createLibraryTsConfigFiles(workspaceRoot, outputDir) {
+    const rootTsConfig = toPosixPath((0, node_path_1.relative)(outputDir, (0, node_path_1.resolve)(workspaceRoot, 'tsconfig.json')));
+    const outDir = toPosixPath((0, node_path_1.relative)(outputDir, (0, node_path_1.resolve)(workspaceRoot, 'out-tsc/lib')));
+    const distDir = toRecursiveGlob((0, node_path_1.relative)(outputDir, (0, node_path_1.resolve)(workspaceRoot, 'dist')));
+    const nodeModulesDir = toRecursiveGlob((0, node_path_1.relative)(outputDir, (0, node_path_1.resolve)(workspaceRoot, 'node_modules')));
+    const tsconfigLib = {
+        extends: rootTsConfig,
+        compilerOptions: {
+            outDir,
+            declaration: true,
+            declarationMap: true,
+            types: [],
+        },
+        include: ['public-api.ts', '**/public-api.ts'],
+        exclude: ['**/*.spec.ts', distDir, nodeModulesDir],
+    };
+    const tsconfigLibProd = {
+        extends: './tsconfig.lib.json',
+        compilerOptions: {
+            declarationMap: false,
+        },
+        angularCompilerOptions: {
+            compilationMode: 'partial',
+        },
+    };
+    return [
+        {
+            path: 'tsconfig.lib.json',
+            content: (0, template_1.finalize)(JSON.stringify(tsconfigLib, null, 2)),
+        },
+        {
+            path: 'tsconfig.lib.prod.json',
+            content: (0, template_1.finalize)(JSON.stringify(tsconfigLibProd, null, 2)),
+        },
+    ];
+}
+function toRecursiveGlob(value) {
+    const normalized = toPosixPath(value).replace(/\/+$/, '');
+    return normalized === '.' ? './**' : `${normalized}/**`;
+}
+function toPosixPath(value) {
+    return value.split('\\').join('/');
+}
+function createNgPackageFile(path, content) {
+    return {
+        path,
+        content: (0, template_1.finalize)(JSON.stringify(content, null, 2)),
+    };
+}