codz-cli 0.0.0-stage → 0.1.0

package/dist/input/endpoint.js

@@ -0,0 +1,220 @@
+// Builds the universal EndpointSpec from parsed input. Every rule here is
+// framework-neutral; adapters turn the spec into code.
+import { ToolError } from "../core/types.js";
+import { inferModels, signature, unwrapEnvelope } from "./infer.js";
+import { safeDecode } from "./curl.js";
+import { checkHost, encodePathSegment } from "../core/safe.js";
+import { camel, functionName, pascal, singular, typeName } from "./naming.js";
+const VERSION_SEGMENT = /^(api|v\d+(\.\d+)?|rest)$/i;
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const OBJECT_ID = /^[0-9a-f]{24}$/i;
+function isIdLike(seg) {
+    if (/^\d+$/.test(seg))
+        return 'int';
+    if (UUID.test(seg) || OBJECT_ID.test(seg))
+        return 'string';
+    return null;
+}
+export function analyzePath(rawPath, override) {
+    const segs = rawPath.split('/').filter(Boolean).map((s) => {
+        try {
+            return decodeURIComponent(s);
+        }
+        catch {
+            return s;
+        }
+    });
+    const overrideSegs = override ? override.split('/').filter(Boolean) : null;
+    if (overrideSegs && overrideSegs.length !== segs.length) {
+        throw new ToolError('bad_path', `--path "${override}" has ${overrideSegs.length} segments but the URL has ${segs.length}.`);
+    }
+    const params = [];
+    const nouns = [];
+    const out = [];
+    const paramIndexes = [];
+    segs.forEach((seg, i) => {
+        const o = overrideSegs?.[i];
+        const explicit = (o ?? seg).match(/^(?:\{([^/{}]+)\}|:([\w.-]+))$/);
+        if (explicit) {
+            paramIndexes.push(i);
+            params.push({ name: camel(explicit[1] ?? explicit[2]), example: seg, type: isIdLike(seg) ?? 'string' });
+            out.push(`{${camel(explicit[1] ?? explicit[2])}}`);
+            return;
+        }
+        if (o && o !== seg) {
+            throw new ToolError('bad_path', `--path segment "${o}" does not match the URL segment "${seg}".`);
+        }
+        const kind = overrideSegs ? null : isIdLike(seg);
+        if (kind) {
+            paramIndexes.push(i);
+            params.push({ name: '', example: seg, type: kind });
+            out.push('');
+        }
+        else {
+            // Kept percent-encoded: a literal segment never carries quotes, backticks, $ or comment ends into code.
+            out.push(encodePathSegment(seg));
+            // Names come from the words: /config.json is "config", /user-settings is "user settings".
+            const noun = seg.replace(/\.(json|xml|php|aspx?|html?|jsp|cgi|do)$/i, '');
+            if (noun && (!VERSION_SEGMENT.test(seg) || nouns.length > 0))
+                nouns.push(noun);
+        }
+    });
+    // Name inferred params: a parameter at the very end is "id"; any other is "<parent>Id".
+    paramIndexes.forEach((segIndex, pi) => {
+        const p = params[pi];
+        if (p.name !== '')
+            return;
+        const prev = segIndex > 0 ? segs[segIndex - 1] : 'item';
+        p.name = segIndex === segs.length - 1 ? 'id' : `${camel(singular(prev))}Id`;
+        out[segIndex] = `{${p.name}}`;
+    });
+    const names = new Set();
+    for (const p of params) {
+        if (names.has(p.name))
+            throw new ToolError('bad_path', `Two path parameters are both called "${p.name}". Use --path to name them.`);
+        names.add(p.name);
+    }
+    return { path: '/' + out.join('/'), params, nouns, endsWithParam: paramIndexes.length > 0 && paramIndexes[paramIndexes.length - 1] === segs.length - 1 };
+}
+export function deriveName(method, a) {
+    const nouns = a.nouns.length ? a.nouns : ['root'];
+    const last = nouns[nouns.length - 1];
+    const parents = nouns.slice(0, -1).map((n) => pascal(singular(n)));
+    const prefix = parents.join('');
+    const isPluralNoun = /s$/i.test(last) && !/(ss|us|is)$/i.test(last);
+    // Action endpoints: POST /users/{id}/activate → activateUser
+    if (method === 'POST' && !a.endsWithParam && !isPluralNoun && parents.length > 0) {
+        return { name: camel(`${last} ${prefix}`), target: singular(nouns[nouns.length - 2]) };
+    }
+    const single = pascal(singular(last));
+    switch (method) {
+        case 'GET':
+            return { name: camel(`get ${prefix} ${a.endsWithParam || !isPluralNoun ? single : pascal(last)}`), target: last };
+        case 'POST':
+            return { name: camel(`create ${prefix} ${single}`), target: last };
+        case 'PUT':
+        case 'PATCH':
+            return { name: camel(`update ${prefix} ${single}`), target: last };
+        case 'DELETE':
+            return { name: camel(`delete ${prefix} ${single}`), target: last };
+        default:
+            return { name: camel(`${method.toLowerCase()} ${prefix} ${single}`), target: last };
+    }
+}
+function queryType(value) {
+    if (/^-?\d+$/.test(value))
+        return { kind: 'int' };
+    if (/^-?\d*\.\d+$/.test(value))
+        return { kind: 'double' };
+    if (/^(true|false)$/i.test(value))
+        return { kind: 'bool' };
+    return { kind: 'string' };
+}
+function parseBody(body) {
+    if (body === undefined || body === '')
+        return undefined;
+    const t = body.trim();
+    if (t.startsWith('{') || t.startsWith('[')) {
+        try {
+            return JSON.parse(t);
+        }
+        catch {
+            throw new ToolError('bad_body', 'The request body in the cURL looks like JSON but does not parse.');
+        }
+    }
+    // Form-encoded: a=1&b=two
+    const obj = {};
+    for (const pair of t.split('&')) {
+        const eqAt = pair.indexOf('=');
+        const k = eqAt === -1 ? pair : pair.slice(0, eqAt);
+        const v = eqAt === -1 ? '' : pair.slice(eqAt + 1);
+        if (k)
+            obj[safeDecode(k)] = safeDecode(v);
+    }
+    return obj;
+}
+function renameIn(t, from, to) {
+    if (t.kind === 'object' && t.model === from)
+        return { kind: 'object', model: to };
+    if (t.kind === 'array')
+        return { kind: 'array', item: renameIn(t.item, from, to) };
+    return t;
+}
+export function buildEndpoint(input) {
+    const warnings = [...(input.warnings ?? [])];
+    if (input.url.hostname !== 'api.invalid')
+        checkHost(input.url);
+    const analysis = analyzePath(input.url.pathname, input.path);
+    const derived = deriveName(input.method, analysis);
+    const name = input.name ? functionName(input.name, input.method, derived.name) : derived.name;
+    const resource = analysis.nouns[0] ?? 'root';
+    const queryParams = [];
+    for (const [k, v] of input.url.searchParams.entries()) {
+        if (!queryParams.some((q) => q.name === k))
+            queryParams.push({ name: k, type: queryType(v) });
+    }
+    // Response.
+    let samples = input.responseSamples;
+    let unwrapData = false;
+    if (input.unwrap !== 'never') {
+        const inner = unwrapEnvelope(samples);
+        if (inner) {
+            samples = inner;
+            unwrapData = true;
+            warnings.push('The response is wrapped in {"data": ...}; the generated code returns the inner "data" value. Use --no-unwrap to keep the wrapper.');
+        }
+    }
+    const rootModelName = input.modelName ? typeName(input.modelName) : typeName(singular(derived.target));
+    let response;
+    const models = [];
+    if (samples.length) {
+        const r = inferModels(samples, rootModelName);
+        response = r.root;
+        models.push(...r.models);
+        warnings.push(...r.warnings.map((w) => `Response: ${w.replace(/^\$/, 'root')}`));
+    }
+    else if (input.method !== 'DELETE' && input.method !== 'HEAD') {
+        warnings.push('No response sample was given, so the response type is unknown. Pass --sample <file.json> or paste the response after the cURL.');
+    }
+    // Request.
+    let request;
+    const bodySample = input.requestSample ?? parseBody(input.body);
+    if (bodySample !== undefined) {
+        const r = inferModels([bodySample], `${pascal(name)} Request`);
+        let reqRoot = r.root;
+        const reqModels = r.models;
+        // Merge with response models: reuse identical shapes, rename clashes.
+        for (const m of [...reqModels]) {
+            const same = models.find((x) => x.name === m.name);
+            if (!same)
+                continue;
+            if (signature(same.fields) === signature(m.fields)) {
+                reqModels.splice(reqModels.indexOf(m), 1);
+            }
+            else {
+                const to = `${m.name}Input`;
+                for (const other of reqModels)
+                    other.fields = other.fields.map((f) => ({ ...f, type: renameIn(f.type, m.name, to) }));
+                reqRoot = renameIn(reqRoot, m.name, to);
+                m.name = to;
+            }
+        }
+        request = reqRoot;
+        models.push(...reqModels);
+        warnings.push(...r.warnings.map((w) => `Request: ${w.replace(/^\$/, 'body')}`));
+    }
+    return {
+        name,
+        method: input.method,
+        origin: input.url.hostname === 'api.invalid' ? '' : input.url.origin,
+        path: analysis.path,
+        resource,
+        pathParams: analysis.params,
+        queryParams,
+        response,
+        unwrapData,
+        request,
+        models,
+        warnings,
+    };
+}

package/dist/input/har.js

@@ -0,0 +1,120 @@
+// HAR import: the requests a browser recorded (DevTools → Network → Save all as
+// HAR). JSON API calls are grouped by method and normalized path, and every
+// response of a group becomes a sample for the model.
+//
+// A HAR file holds cookies, auth headers and personal data. Headers are never
+// read; secret query parameters are dropped; bodies are only used to infer
+// types and are never written, cached or kept in history.
+import { ToolError } from "../core/types.js";
+import { stripSecretQuery } from "./curl.js";
+import { analyzePath, buildEndpoint } from "./endpoint.js";
+const ANALYTICS = /(google-analytics|googletagmanager|doubleclick|segment\.(io|com)|sentry\.io|hotjar|mixpanel|amplitude|datadoghq|newrelic|nr-data|intercom|facebook\.(com|net)|clarity\.ms|fullstory|launchdarkly|stripe\.network|cloudflareinsights|vercel-insights|posthog)/i;
+const METHODS = new Set(['GET', 'POST', 'PUT', 'PATCH', 'DELETE']);
+export const isHar = (doc) => !!doc && typeof doc === 'object' && !!doc.log && Array.isArray(doc.log.entries);
+function bodyText(content) {
+    if (!content?.text)
+        return undefined;
+    return content.encoding === 'base64' ? Buffer.from(content.text, 'base64').toString('utf8') : content.text;
+}
+function json(text) {
+    if (text === undefined || text.trim() === '')
+        return undefined;
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readHar(doc, opts = {}) {
+    const warnings = [];
+    const groups = new Map();
+    let skipped = { notJson: 0, errors: 0, analytics: 0, other: 0, outside: 0 };
+    const removed = [];
+    for (const e of doc.log.entries) {
+        const method = String(e.request?.method ?? '').toUpperCase();
+        const raw = e.request?.url ?? '';
+        if (!METHODS.has(method) || !/^https?:\/\//.test(raw)) {
+            skipped.other++;
+            continue;
+        }
+        let url;
+        try {
+            url = new URL(raw);
+        }
+        catch {
+            skipped.other++;
+            continue;
+        }
+        if (ANALYTICS.test(url.hostname)) {
+            skipped.analytics++;
+            continue;
+        }
+        if (opts.baseUrl && !raw.startsWith(opts.baseUrl.replace(/\/$/, ''))) {
+            skipped.outside++;
+            continue;
+        }
+        const status = e.response?.status ?? 0;
+        if ((status < 200 || status >= 300) && !opts.includeErrors) {
+            skipped.errors++;
+            continue;
+        }
+        const mime = e.response?.content?.mimeType ?? '';
+        const body = json(bodyText(e.response?.content));
+        const isDelete = method === 'DELETE' || status === 204;
+        if (!/json/i.test(mime) && !(isDelete && !mime)) {
+            skipped.notJson++;
+            continue;
+        }
+        stripSecretQuery(url, removed);
+        let path;
+        try {
+            path = analyzePath(url.pathname).path;
+        }
+        catch {
+            skipped.other++;
+            continue;
+        }
+        const key = `${method} ${url.host}${path}`;
+        const g = groups.get(key) ?? { method: method, url, samples: [], count: 0, host: url.host };
+        g.count++;
+        if (body !== undefined && g.samples.length < 10)
+            g.samples.push(body);
+        for (const [k, v] of url.searchParams)
+            if (!g.url.searchParams.has(k))
+                g.url.searchParams.set(k, v);
+        if (g.request === undefined && /json/i.test(e.request?.postData?.mimeType ?? 'json'))
+            g.request = json(e.request?.postData?.text);
+        groups.set(key, g);
+    }
+    if (!groups.size) {
+        throw new ToolError('no_endpoints', 'The HAR file has no JSON API calls to import.', `Skipped: ${skipped.notJson} non-JSON, ${skipped.errors} failed (use --include-errors), ${skipped.analytics} analytics, ${skipped.outside} outside --base-url, ${skipped.other} other.`);
+    }
+    const hosts = [...new Set([...groups.values()].map((g) => g.host))];
+    if (hosts.length > 1 && !opts.baseUrl)
+        warnings.push(`Requests go to ${hosts.length} hosts (${hosts.join(', ')}). Pass --base-url https://<host> to import only your API.`);
+    if (removed.length)
+        warnings.push(`Removed from the URLs and never written anywhere: ${[...new Set(removed)].join(', ')}.`);
+    const skippedTotal = skipped.notJson + skipped.errors + skipped.analytics + skipped.other + skipped.outside;
+    if (skippedTotal)
+        warnings.push(`Skipped ${skippedTotal} request${skippedTotal === 1 ? '' : 's'}: ${skipped.notJson} not JSON, ${skipped.errors} failed${skipped.errors ? ' (--include-errors keeps them)' : ''}, ${skipped.analytics} analytics, ${skipped.outside} outside --base-url, ${skipped.other} other.`);
+    const operations = [];
+    const used = new Set();
+    for (const g of groups.values()) {
+        try {
+            const spec = buildEndpoint({ method: g.method, url: g.url, responseSamples: g.samples, requestSample: g.request });
+            if (used.has(spec.name)) {
+                let n = 2;
+                while (used.has(`${spec.name}${n}`))
+                    n++;
+                spec.name = `${spec.name}${n}`;
+            }
+            used.add(spec.name);
+            operations.push({ spec, tags: [g.host], source: `${g.method} ${g.host}${spec.path} (${g.count} request${g.count === 1 ? '' : 's'})` });
+        }
+        catch (e) {
+            warnings.push(`${g.method} ${g.url.pathname}: ${e.message}`);
+        }
+    }
+    return { format: 'har', title: `HAR from ${doc.log.creator?.name ?? 'a browser'} (${doc.log.entries.length} requests)`, operations, warnings };
+}

package/dist/input/infer.js

@@ -0,0 +1,174 @@
+// Infers models from one or more JSON samples. Rules are fixed and
+// documented, so the same samples always give the same models.
+//
+// - Several samples are merged: a field missing or null in any sample is nullable.
+// - Integers become double when any sample has a fraction, or when the field
+//   name suggests money, rates or coordinates (price, amount, lat, ...).
+// - ISO 8601 strings become dates. Enums are never inferred.
+// - A field that is only ever null, or an array that is only ever empty, gets
+//   an "unknown" type and a warning instead of a guess.
+// - Identical object shapes are reused; same name with a different shape gets
+//   the parent name as a prefix.
+import { pascal, singular } from "./naming.js";
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
+const GENERIC_NAMES = new Set(['Item', 'Data', 'Detail', 'Details', 'Info', 'Meta', 'Value', 'Result', 'Attribute', 'Attributes', 'Entry', 'Node', 'Element', 'Record', 'Object', 'Option', 'Setting', 'Config']);
+const DOUBLE_HINT = /(price|amount|total|subtotal|rate|ratio|lat|lng|lon|latitude|longitude|score|percent|percentage|balance|cost|fee|weight|height|width|discount|tax|rating)$/i;
+function emptyShape() {
+    return { seen: 0, nulls: 0, strings: 0, dateStrings: 0, ints: 0, doubles: 0, bools: 0, objects: 0, arrays: 0, emptyArrays: 0, fields: new Map(), keyOrder: [], items: null };
+}
+function add(shape, value) {
+    shape.seen++;
+    if (value === null || value === undefined)
+        shape.nulls++;
+    else if (typeof value === 'string') {
+        shape.strings++;
+        if (ISO_DATE.test(value))
+            shape.dateStrings++;
+    }
+    else if (typeof value === 'number') {
+        if (Number.isInteger(value))
+            shape.ints++;
+        else
+            shape.doubles++;
+    }
+    else if (typeof value === 'boolean')
+        shape.bools++;
+    else if (Array.isArray(value)) {
+        shape.arrays++;
+        if (value.length === 0)
+            shape.emptyArrays++;
+        shape.items ??= emptyShape();
+        for (const item of value)
+            add(shape.items, item);
+    }
+    else if (typeof value === 'object') {
+        shape.objects++;
+        for (const [k, v] of Object.entries(value)) {
+            if (!shape.fields.has(k)) {
+                shape.fields.set(k, emptyShape());
+                shape.keyOrder.push(k);
+            }
+            add(shape.fields.get(k), v);
+        }
+    }
+}
+export function signature(fields) {
+    return fields
+        .map((f) => `${f.jsonName}:${typeKey(f.type)}${f.nullable ? '?' : ''}`)
+        .sort()
+        .join(',');
+}
+function typeKey(t) {
+    if (t.kind === 'array')
+        return `[${typeKey(t.item)}]`;
+    if (t.kind === 'object')
+        return `{${t.model}}`;
+    return t.kind;
+}
+export function inferModels(samples, rootName) {
+    const shape = emptyShape();
+    for (const s of samples)
+        add(shape, s);
+    const models = [];
+    const bySignature = new Map();
+    const byName = new Map();
+    const warnings = [];
+    function toType(s, path, nameHint, parentName, fieldName) {
+        const nullable = s.nulls > 0;
+        const nonNull = s.seen - s.nulls;
+        if (nonNull === 0) {
+            warnings.push(`${path} is null in every sample, so its type is unknown. Pass a sample where it has a value.`);
+            return { type: { kind: 'unknown' }, nullable: true };
+        }
+        const kinds = [s.strings > 0, s.ints + s.doubles > 0, s.bools > 0, s.objects > 0, s.arrays > 0].filter(Boolean).length;
+        if (kinds > 1) {
+            warnings.push(`${path} has different types in the samples (for example text and number), so its type is unknown.`);
+            return { type: { kind: 'unknown' }, nullable };
+        }
+        if (s.strings > 0)
+            return { type: { kind: s.dateStrings === s.strings ? 'date' : 'string' }, nullable };
+        if (s.ints + s.doubles > 0) {
+            const isDouble = s.doubles > 0 || DOUBLE_HINT.test(fieldName);
+            return { type: { kind: isDouble ? 'double' : 'int' }, nullable };
+        }
+        if (s.bools > 0)
+            return { type: { kind: 'bool' }, nullable };
+        if (s.arrays > 0) {
+            const items = s.items;
+            if (items.seen === 0) {
+                warnings.push(`${path} is an empty list in every sample, so its item type is unknown. Pass a sample with at least one item.`);
+                return { type: { kind: 'array', item: { kind: 'unknown' } }, nullable };
+            }
+            // A list under a singular key ("checklist") holds "ChecklistItem"s.
+            const itemHint = parentName !== '' && singular(nameHint) === nameHint && s.items.objects > 0 ? `${nameHint} Item` : singular(nameHint);
+            const item = toType(items, `${path}[]`, itemHint, parentName, singular(fieldName));
+            if (item.nullable)
+                warnings.push(`${path} contains null items; they are typed as non-null.`);
+            return { type: { kind: 'array', item: item.type }, nullable };
+        }
+        // Object.
+        const name = objectModel(s, path, nameHint, parentName);
+        return { type: { kind: 'object', model: name }, nullable };
+    }
+    function objectModel(s, path, nameHint, parentName) {
+        let base = pascal(nameHint) || 'Item';
+        if (GENERIC_NAMES.has(base) && parentName)
+            base = pascal(`${parentName} ${base}`);
+        const fields = [];
+        for (const key of s.keyOrder) {
+            const f = s.fields.get(key);
+            const childName = pascal(key);
+            const { type, nullable } = toType(f, `${path}.${key}`, childName, base, key);
+            fields.push({ jsonName: key, type, nullable: nullable || f.seen < s.objects });
+        }
+        const sig = signature(fields);
+        const reuse = bySignature.get(sig);
+        if (reuse)
+            return reuse;
+        let name = base;
+        if (byName.has(name) && !parentName) {
+            // The root model takes a "Response" suffix rather than a number.
+            name = `${base}Response`;
+            let n = 2;
+            while (byName.has(name))
+                name = `${base}Response${n++}`;
+        }
+        else if (byName.has(name)) {
+            name = pascal(`${parentName} ${base}`);
+            let n = 2;
+            while (byName.has(name))
+                name = `${pascal(`${parentName} ${base}`)}${n++}`;
+        }
+        const model = { name, fields };
+        byName.set(name, model);
+        bySignature.set(sig, name);
+        models.push(model);
+        return name;
+    }
+    const { type } = samples.length ? toType(shape, '$', rootName, '', rootName) : { type: { kind: 'unknown' } };
+    return { root: type, models, warnings };
+}
+const META_KEYS = new Set(['meta', 'status', 'message', 'success', 'code', 'errors', 'error', 'pagination', 'links', 'total', 'page', 'per_page', 'perPage', 'count', 'timestamp']);
+/**
+ * Detects a response envelope such as {"data": {...}, "meta": {...}}. Returns
+ * the inner samples when every sample is an envelope, or null.
+ */
+export function unwrapEnvelope(samples) {
+    if (!samples.length)
+        return null;
+    const inner = [];
+    for (const s of samples) {
+        if (!s || typeof s !== 'object' || Array.isArray(s))
+            return null;
+        const obj = s;
+        if (!('data' in obj))
+            return null;
+        if (!Object.keys(obj).every((k) => k === 'data' || META_KEYS.has(k)))
+            return null;
+        const d = obj.data;
+        if (d === null || typeof d !== 'object')
+            return null;
+        inner.push(d);
+    }
+    return inner;
+}

package/dist/input/naming.js

@@ -0,0 +1,145 @@
+// Deterministic naming helpers shared by skills and adapters.
+export function words(input) {
+    return input
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/([A-Z]+)([A-Z][a-z])/g, '$1 $2')
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((w) => w.toLowerCase());
+}
+const cap = (w) => (w ? w[0].toUpperCase() + w.slice(1) : w);
+export const pascal = (s) => words(s).map(cap).join('');
+export const camel = (s) => {
+    const p = pascal(s);
+    return p ? p[0].toLowerCase() + p.slice(1) : p;
+};
+export const snake = (s) => words(s).join('_');
+export const kebab = (s) => words(s).join('-');
+export function fileName(base, style) {
+    switch (style) {
+        case 'camel':
+            return camel(base);
+        case 'pascal':
+            return pascal(base);
+        case 'snake':
+            return snake(base);
+        default:
+            return kebab(base);
+    }
+}
+/** Guesses the naming style of a set of file base names (without extension). */
+export function detectFileNaming(names, fallback) {
+    const counts = { kebab: 0, camel: 0, pascal: 0, snake: 0 };
+    for (const n of names) {
+        if (n.includes('-'))
+            counts.kebab++;
+        else if (n.includes('_'))
+            counts.snake++;
+        else if (/^[A-Z]/.test(n) && /[a-z]/.test(n))
+            counts.pascal++;
+        else if (/^[a-z]+[A-Z]/.test(n))
+            counts.camel++;
+    }
+    let best = fallback;
+    let bestCount = 0;
+    for (const style of ['kebab', 'camel', 'pascal', 'snake']) {
+        if (counts[style] > bestCount) {
+            best = style;
+            bestCount = counts[style];
+        }
+    }
+    return best;
+}
+const IRREGULAR = {
+    people: 'person',
+    children: 'child',
+    men: 'man',
+    women: 'woman',
+    data: 'data',
+    news: 'news',
+    status: 'status',
+    series: 'series',
+    species: 'species',
+    analytics: 'analytics',
+    settings: 'settings',
+    me: 'me',
+};
+/** Singularizes the last word of an identifier, keeping its case style. */
+export function singular(word) {
+    const lower = word.toLowerCase();
+    if (IRREGULAR[lower])
+        return matchCase(word, IRREGULAR[lower]);
+    if (/ies$/i.test(word) && word.length > 4)
+        return word.slice(0, -3) + matchCase(word.slice(-3), 'y');
+    if (/(ss|us|is)$/i.test(word))
+        return word;
+    if (/(ss|x|ch|sh|z|us)es$/i.test(word))
+        return word.slice(0, -2);
+    if (/s$/i.test(word) && word.length > 2)
+        return word.slice(0, -1);
+    return word;
+}
+export function plural(word) {
+    if (/[^aeiou]y$/i.test(word))
+        return word.slice(0, -1) + 'ies';
+    if (/(s|x|ch|sh)$/i.test(word))
+        return word + 'es';
+    return word + 's';
+}
+function matchCase(source, target) {
+    if (source === source.toUpperCase())
+        return target.toUpperCase();
+    if (source[0] === source[0].toUpperCase())
+        return cap(target);
+    return target;
+}
+/** Makes a safe identifier from any string (used for JSON keys that are not valid identifiers). */
+export function identifier(jsonKey, reserved) {
+    let id = camel(jsonKey);
+    if (!id)
+        id = 'field';
+    if (/^[0-9]/.test(id))
+        id = `n${id}`;
+    if (reserved.has(id))
+        id = `${id}Value`;
+    return id;
+}
+export const TS_RESERVED = new Set([
+    'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'enum', 'export',
+    'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return', 'super',
+    'switch', 'this', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with',
+]);
+export const DART_RESERVED = new Set([
+    'abstract', 'as', 'assert', 'async', 'await', 'break', 'case', 'catch', 'class', 'const', 'continue', 'covariant',
+    'default', 'deferred', 'do', 'dynamic', 'else', 'enum', 'export', 'extends', 'extension', 'external', 'factory', 'false',
+    'final', 'finally', 'for', 'Function', 'get', 'hide', 'if', 'implements', 'import', 'in', 'interface', 'is', 'late',
+    'library', 'mixin', 'new', 'null', 'on', 'operator', 'part', 'required', 'rethrow', 'return', 'set', 'show', 'static',
+    'super', 'switch', 'sync', 'this', 'throw', 'true', 'try', 'typedef', 'var', 'void', 'while', 'with', 'yield', 'hashCode',
+    'runtimeType', 'toString', 'noSuchMethod',
+]);
+/**
+ * A function name that compiles in both TypeScript and Dart. Names from an
+ * operationId, a Postman item or --name can be reserved words ("delete") or
+ * start with a digit ("2fa.verify"). A reserved word falls back to the name
+ * derived from the path (deleteUser); a leading digit gets the method in front.
+ */
+export function functionName(raw, method, fallback) {
+    let name = camel(raw);
+    if (!name)
+        name = fallback ?? camel(`${method} request`);
+    if (/^[0-9]/.test(name))
+        name = `${method.toLowerCase()}${name}`;
+    if (TS_RESERVED.has(name) || DART_RESERVED.has(name)) {
+        name = fallback && fallback !== name && !TS_RESERVED.has(fallback) && !DART_RESERVED.has(fallback) ? fallback : `${name}Request`;
+    }
+    return name;
+}
+/** A class or interface name that compiles in both languages. */
+export function typeName(raw, fallback = 'Item') {
+    let name = pascal(raw) || fallback;
+    if (/^[0-9]/.test(name))
+        name = `${fallback === 'Item' ? 'Model' : fallback}${name}`;
+    if (TS_RESERVED.has(name) || DART_RESERVED.has(name))
+        name = `${name}Model`;
+    return name;
+}