vouchington-tooling 0.33.0 → 0.34.0

package/dist/finite-enum-ripple/create-page-literals.mjs

@@ -0,0 +1,83 @@
+import ts from '@typescript/typescript6';
+import { getStringLiteralValue, unwrapExpression } from './ast.mjs';
+import { jsxRuntimeStringValue } from './create-page-jsx.mjs';
+import { getConfiguredPropertyName, isConfiguredPropertyName } from './create-page-properties.mjs';
+import { visitCreatePageObject } from './create-page-object-visitor.mjs';
+/** Inspect syntax nodes so comments and strings containing example code are ignored. */
+export function collectCreatePageLiterals(content, file, properties) {
+    const scriptKind = file.endsWith('.tsx') || file.endsWith('.jsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true, scriptKind);
+    const names = new Set(properties);
+    const values = [];
+    const assignedPropertyName = (target) => {
+        const left = unwrapExpression(target);
+        return ts.isIdentifier(left)
+            ? left.text
+            : ts.isPropertyAccessExpression(left)
+                ? left.name.text
+                : ts.isElementAccessExpression(left)
+                    ? getStringLiteralValue(left.argumentExpression)
+                    : undefined;
+    };
+    const visit = (node, ignoredProperties = new Set()) => {
+        if (ts.isObjectLiteralExpression(node) || ts.isJsxAttributes(node)) {
+            visitCreatePageObject(node, names, ignoredProperties, file, visit);
+            return;
+        }
+        if (ts.isPropertyAssignment(node)) {
+            const name = getConfiguredPropertyName(node, names);
+            if (isConfiguredPropertyName(name, names) && !ignoredProperties.has(name)) {
+                const value = getStringLiteralValue(node.initializer);
+                if (value === undefined)
+                    throw new Error(`${file}: create page ${name} must be a string literal`);
+                values.push(value);
+            }
+            ts.forEachChild(node, (child) => visit(child, new Set()));
+            return;
+        }
+        else if (ts.isShorthandPropertyAssignment(node) && names.has(node.name.text)) {
+            throw new Error(`${file}: create page ${node.name.text} must be a string literal`);
+        }
+        else if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && names.has(node.name.text)) {
+            const value = node.initializer && ts.isJsxExpression(node.initializer)
+                ? getStringLiteralValue(node.initializer.expression)
+                : node.initializer && ts.isStringLiteral(node.initializer)
+                    ? jsxRuntimeStringValue(node.initializer, source, file)
+                    : getStringLiteralValue(node.initializer);
+            if (value === undefined)
+                throw new Error(`${file}: create page ${node.name.text} must be a string literal`);
+            values.push(value);
+        }
+        else if ((ts.isPrefixUnaryExpression(node) || ts.isPostfixUnaryExpression(node)) &&
+            (node.operator === ts.SyntaxKind.PlusPlusToken ||
+                node.operator === ts.SyntaxKind.MinusMinusToken)) {
+            const name = assignedPropertyName(node.operand);
+            if (isConfiguredPropertyName(name, names))
+                throw new Error(`${file}: unary mutation of create page ${name} is uninspectable`);
+        }
+        else if (ts.isDeleteExpression(node)) {
+            const name = assignedPropertyName(node.expression);
+            if (isConfiguredPropertyName(name, names))
+                throw new Error(`${file}: deletion of create page ${name} is uninspectable`);
+        }
+        else if (ts.isBinaryExpression(node)) {
+            const name = assignedPropertyName(node.left);
+            if (node.operatorToken.kind >= ts.SyntaxKind.FirstCompoundAssignment &&
+                node.operatorToken.kind <= ts.SyntaxKind.LastCompoundAssignment &&
+                isConfiguredPropertyName(name, names))
+                throw new Error(`${file}: compound assignment to create page ${name} is uninspectable`);
+            if (node.operatorToken.kind !== ts.SyntaxKind.EqualsToken) {
+                ts.forEachChild(node, (child) => visit(child));
+                return;
+            }
+            const value = getStringLiteralValue(node.right);
+            if (isConfiguredPropertyName(name, names) && value === undefined)
+                throw new Error(`${file}: create page ${name} must be a string literal`);
+            if (isConfiguredPropertyName(name, names) && value !== undefined)
+                values.push(value);
+        }
+        ts.forEachChild(node, (child) => visit(child));
+    };
+    visit(source);
+    return values;
+}

package/dist/finite-enum-ripple/create-page-object-visitor.d.mts

@@ -0,0 +1,2 @@
+import ts from '@typescript/typescript6';
+export declare function visitCreatePageObject(node: ts.ObjectLiteralExpression | ts.JsxAttributes, names: ReadonlySet<string>, ignoredProperties: ReadonlySet<string>, file: string, visit: (node: ts.Node, ignoredProperties?: ReadonlySet<string>) => void): void;

package/dist/finite-enum-ripple/create-page-object-visitor.mjs

@@ -0,0 +1,57 @@
+import ts from '@typescript/typescript6';
+import { getStringLiteralValue, unwrapExpression } from './ast.mjs';
+import { getConfiguredPropertyName, isConfiguredPropertyName, spreadMayOverrideConfiguredProperty, } from './create-page-properties.mjs';
+export function visitCreatePageObject(node, names, ignoredProperties, file, visit) {
+    let configuredBeforeSpread = false;
+    for (const member of node.properties) {
+        if (ts.isSpreadAssignment(member) || ts.isJsxSpreadAttribute(member)) {
+            if (configuredBeforeSpread && spreadMayOverrideConfiguredProperty(member, names))
+                throw new Error(`${file}: create page type can be overridden by a trailing spread`);
+        }
+        else if (ts.isPropertyAssignment(member) &&
+            getConfiguredPropertyName(member, names) === '__proto__' &&
+            !ts.isComputedPropertyName(member.name)) {
+            throw new Error(`${file}: create page __proto__ prototype setter is uninspectable`);
+        }
+        else if (getConfiguredPropertyName(member, names) !== undefined) {
+            configuredBeforeSpread = true;
+        }
+        else if (ts.isPropertyAssignment(member) &&
+            ts.isComputedPropertyName(member.name) &&
+            getStringLiteralValue(member.name.expression) === undefined &&
+            configuredBeforeSpread) {
+            throw new Error(`${file}: create page type can be overridden by a trailing computed property`);
+        }
+    }
+    for (let index = 0; index < node.properties.length; index += 1) {
+        const member = node.properties[index];
+        if (ts.isSpreadAssignment(member) || ts.isJsxSpreadAttribute(member)) {
+            const overridden = new Set();
+            const expression = unwrapExpression(member.expression);
+            if (!ts.isObjectLiteralExpression(expression) &&
+                spreadMayOverrideConfiguredProperty(member, names)) {
+                for (const later of node.properties.slice(index + 1)) {
+                    const name = getConfiguredPropertyName(later, names);
+                    if (isConfiguredPropertyName(name, names))
+                        overridden.add(name);
+                }
+                if ([...names].some((name) => !overridden.has(name)))
+                    throw new Error(`${file}: create page type cannot be inspected through a leading spread`);
+            }
+            if (ts.isObjectLiteralExpression(expression)) {
+                for (const later of node.properties.slice(index + 1)) {
+                    const name = getConfiguredPropertyName(later, names);
+                    if (isConfiguredPropertyName(name, names))
+                        overridden.add(name);
+                }
+            }
+            visit(expression, overridden);
+        }
+        else {
+            const name = getConfiguredPropertyName(member, names);
+            if (isConfiguredPropertyName(name, names) && ignoredProperties.has(name))
+                continue;
+            visit(member, ignoredProperties);
+        }
+    }
+}

package/dist/finite-enum-ripple/create-page-properties.d.mts

@@ -0,0 +1,4 @@
+import ts from '@typescript/typescript6';
+export declare function getConfiguredPropertyName(node: ts.Node, names: ReadonlySet<string>): string | undefined;
+export declare function isConfiguredPropertyName(name: string | undefined, names: ReadonlySet<string>): name is string;
+export declare function spreadMayOverrideConfiguredProperty(member: ts.SpreadAssignment | ts.JsxSpreadAttribute, names: ReadonlySet<string>): boolean;

package/dist/finite-enum-ripple/create-page-properties.mjs

@@ -0,0 +1,35 @@
+import ts from '@typescript/typescript6';
+import { getPropertyNameText, getStringLiteralValue, unwrapExpression } from './ast.mjs';
+export function getConfiguredPropertyName(node, names) {
+    let name;
+    if (ts.isPropertyAssignment(node)) {
+        name = getPropertyNameText(node.name);
+        if (name === undefined && ts.isComputedPropertyName(node.name))
+            name = getStringLiteralValue(node.name.expression);
+    }
+    else if (ts.isShorthandPropertyAssignment(node))
+        name = node.name.text;
+    else if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name))
+        name = node.name.text;
+    return name !== undefined && names.has(name) ? name : undefined;
+}
+export function isConfiguredPropertyName(name, names) {
+    return name !== undefined && names.has(name);
+}
+export function spreadMayOverrideConfiguredProperty(member, names) {
+    return expressionMayOverride(unwrapExpression(member.expression), names);
+}
+function expressionMayOverride(expression, names) {
+    if (!ts.isObjectLiteralExpression(expression))
+        return true;
+    return expression.properties.some((property) => {
+        if (ts.isSpreadAssignment(property))
+            return expressionMayOverride(unwrapExpression(property.expression), names);
+        if (ts.isComputedPropertyName(property.name)) {
+            const name = getStringLiteralValue(property.name.expression);
+            return name === undefined || names.has(name);
+        }
+        const name = getPropertyNameText(property.name);
+        return name !== undefined && names.has(name);
+    });
+}

package/dist/finite-enum-ripple/index.d.mts

@@ -0,0 +1,2 @@
+export { checkFiniteEnumRipple } from './check.mts';
+export type { FiniteEnumFiles, FiniteEnumRippleConfig } from './model.mts';

package/dist/finite-enum-ripple/index.mjs

@@ -0,0 +1 @@
+export { checkFiniteEnumRipple } from './check.mjs';

package/dist/finite-enum-ripple/model.d.mts

@@ -0,0 +1,74 @@
+export type ReadTrackedFile = (file: string) => string;
+export interface RoutedPage {
+    file: string;
+    isTopLevel: boolean;
+    slug: string;
+}
+export interface FiniteEnumFiles {
+    existingFileSet: ReadonlySet<string>;
+    unionCollectionPages: RoutedPage[];
+    unionCreatePages: RoutedPage[];
+    unionDetailPages: RoutedPage[];
+    structuredCollectionPages: RoutedPage[];
+    structuredComponentFiles: {
+        file: string;
+        slug: string;
+    }[];
+    structuredDetailPages: RoutedPage[];
+}
+/** Selection and diagnostics are supplied by the consumer, never inferred from its layout. */
+export interface FiniteEnumRippleConfig {
+    files: FiniteEnumFiles;
+    /** Appended to every diagnostic; use for a consumer-owned policy guide. */
+    diagnosticSuffix?: string;
+    structured?: {
+        backendPath: string;
+        webPath: string;
+        routeConfigsPath: string;
+        typeObject: string;
+        routeConfigObject: string;
+        typeArrayProperty: string;
+        pluralPathProperty: string;
+        singularPathProperty: string;
+        routeExemptionProperty: string;
+        slugProperty: string;
+        slugPluralProperty: string;
+        factoryCallPattern: RegExp;
+        routeConfigExceptions: readonly string[];
+        /** Declared values intentionally without a collection route. */
+        collectionRouteExclusions: readonly string[];
+        routeLabels: {
+            detailTop: string;
+            detail: string;
+            collectionTop: string;
+            collection: string;
+        };
+        collectionLabel: string;
+        ignoredNavigationPaths: readonly string[];
+        collectionPathLiteralPattern: RegExp;
+        navigationPathLiteralPattern: RegExp;
+    };
+    union?: {
+        typesPath: string;
+        routeConfigsPath: string;
+        typeAlias: string;
+        slugMapObject: string;
+        routeConfigObject: string;
+        typeArrayProperty: string;
+        pluralPathProperty: string;
+        singularPathProperty: string;
+        factoryCallPattern: RegExp;
+        internalTypes: readonly string[];
+        routeConfigExceptions: readonly string[];
+        routeLabels: {
+            detailTop: string;
+            detail: string;
+            collectionTop: string;
+            collection: string;
+            factory: string;
+        };
+        collectionLabel: string;
+        createPageTypeProperties: readonly string[];
+        collectionPathLiteralPattern: RegExp;
+    };
+}

package/dist/finite-enum-ripple/model.mjs

@@ -0,0 +1 @@
+export {};

package/dist/finite-enum-ripple/parser-support.d.mts

@@ -0,0 +1,11 @@
+import ts from '@typescript/typescript6';
+export declare function parseRouteConfigEntries(content: string, name: string, file: string, pluralPathProperty: string, singularPathProperty: string): {
+    key: string;
+    body: ts.ObjectLiteralExpression;
+    pluralPath: string;
+    singularPath: string;
+}[];
+export declare function parseStringArray(content: ts.ObjectLiteralExpression, property: string, file: string): string[];
+export declare function collectStringLiteralsFromType(type: ts.TypeNode): string[];
+export declare function getStringProperty(object: ts.ObjectLiteralExpression, property: string): string | undefined;
+export declare function hasTrueProperty(object: ts.ObjectLiteralExpression, property: string): boolean;

package/dist/finite-enum-ripple/parser-support.mjs

@@ -0,0 +1,86 @@
+import ts from '@typescript/typescript6';
+import { findConstObjectLiteral, getPropertyNameText, getStringLiteralValue, unwrapExpression, } from './ast.mjs';
+import { hasPostDeclarationConfiguredObjectMutation } from './configured-object-mutations.mjs';
+export function parseRouteConfigEntries(content, name, file, pluralPathProperty, singularPathProperty) {
+    const object = findConstObjectLiteral(content, name, file);
+    if (hasPostDeclarationConfiguredObjectMutation(content, file, name, object.end))
+        throw new Error(`${file}: ${name} has a post-declaration property mutation`);
+    const entries = [];
+    for (const property of object.properties) {
+        if (!ts.isPropertyAssignment(property))
+            throw new Error(`${file}: ${name} contains an uninspectable route member`);
+        const key = ts.isComputedPropertyName(property.name)
+            ? getStringLiteralValue(property.name.expression)
+            : getPropertyNameText(property.name);
+        if (!key)
+            throw new Error(`${file}: ${name} contains an uninspectable route key`);
+        if (key === '__proto__' && !ts.isComputedPropertyName(property.name))
+            throw new Error(`${file}: ${name} contains unsupported __proto__ prototype setter`);
+        const body = unwrapExpression(property.initializer);
+        if (!ts.isObjectLiteralExpression(body))
+            throw new Error(`${file}: ${name}.${key} must be an object literal`);
+        const names = new Set();
+        for (const member of body.properties) {
+            if (!ts.isPropertyAssignment(member))
+                throw new Error(`${file}: ${name}.${key} contains an uninspectable member`);
+            const memberName = getPropertyNameText(member.name);
+            if (!memberName || names.has(memberName))
+                throw new Error(`${file}: ${name}.${key} contains an uninspectable or duplicate key`);
+            names.add(memberName);
+        }
+        const pluralPath = getStringProperty(body, pluralPathProperty);
+        const singularPath = getStringProperty(body, singularPathProperty);
+        if (!pluralPath)
+            throw new Error(`${file}: ${name}.${key} is missing ${pluralPathProperty}`);
+        if (!singularPath)
+            throw new Error(`${file}: ${name}.${key} is missing ${singularPathProperty}`);
+        entries.push({ key, body, pluralPath, singularPath });
+    }
+    if (entries.length === 0)
+        throw new Error(`${file}: could not parse ${name} entries`);
+    return entries;
+}
+export function parseStringArray(content, property, file) {
+    const array = getPropertyValue(content, property);
+    if (!array)
+        return [];
+    if (!ts.isArrayLiteralExpression(array))
+        throw new Error(`${file}: ${property} must be a literal string array`);
+    return array.elements.map((element) => {
+        const value = getStringLiteralValue(element);
+        if (value === undefined)
+            throw new Error(`${file}: ${property} contains a non-string literal element`);
+        return value;
+    });
+}
+export function collectStringLiteralsFromType(type) {
+    const node = unwrapTypeNode(type);
+    if (ts.isUnionTypeNode(node))
+        return node.types.flatMap((item) => collectStringLiteralsFromType(item));
+    const value = ts.isLiteralTypeNode(node) ? getStringLiteralValue(node.literal) : undefined;
+    if (value === undefined)
+        throw new Error('union contains a non-string literal constituent');
+    return [value];
+}
+function getPropertyValue(object, property) {
+    for (const member of object.properties) {
+        if (!ts.isPropertyAssignment(member))
+            continue;
+        const key = getPropertyNameText(member.name);
+        if (key === property)
+            return unwrapExpression(member.initializer);
+    }
+    return undefined;
+}
+export function getStringProperty(object, property) {
+    return getStringLiteralValue(getPropertyValue(object, property));
+}
+export function hasTrueProperty(object, property) {
+    return getPropertyValue(object, property)?.kind === ts.SyntaxKind.TrueKeyword;
+}
+function unwrapTypeNode(type) {
+    let current = type;
+    while (ts.isParenthesizedTypeNode(current))
+        current = current.type;
+    return current;
+}

package/dist/finite-enum-ripple/parsers.d.mts

@@ -0,0 +1,32 @@
+export interface StructuredTypeEntry {
+    value: string;
+    slug: string;
+    slugPlural: string;
+}
+export interface UnionRouteConfigEntry {
+    key: string;
+    unionTypes: string[];
+    pluralPath: string;
+    singularPath: string;
+}
+export interface StructuredRouteConfigEntry {
+    key: string;
+    structuredTypes: string[];
+    pluralPath: string;
+    singularPath: string;
+    routeExempt: boolean;
+}
+export interface UnionDetailRouteFactoryArgs {
+    unionType: string;
+    slug: string;
+}
+export interface StructuredRouteFactoryArgs {
+    slug: string;
+}
+export declare function parseStructuredTypeEntries(content: string, file: string, name: string, slugProperty: string, slugPluralProperty: string): StructuredTypeEntry[];
+export declare function parseUnionSlugToType(content: string, file: string, name: string): Map<string, string>;
+export declare function parseUnionTypeUnion(content: string, file: string, name: string): string[];
+export declare function parseUnionRouteConfigEntries(content: string, file: string, name: string, typeProperty: string, pluralPathProperty: string, singularPathProperty: string): UnionRouteConfigEntry[];
+export declare function parseStructuredRouteConfigEntries(content: string, file: string, name: string, typeProperty: string, exemptionProperty: string, pluralPathProperty: string, singularPathProperty: string): StructuredRouteConfigEntry[];
+export declare function parseUnionDetailRouteFactoryArgs(content: string, file: string, callPattern: RegExp): UnionDetailRouteFactoryArgs[];
+export declare function parseStructuredRouteFactoryArgs(content: string, file: string, callPattern: RegExp): StructuredRouteFactoryArgs[];

package/dist/finite-enum-ripple/parsers.mjs

@@ -0,0 +1,113 @@
+import ts from '@typescript/typescript6';
+import { collectCallExpressions, findConstObjectLiteral, findTypeAliasDeclaration, getCallExpressionName, getPropertyNameText, getStringLiteralValue, unwrapExpression, } from './ast.mjs';
+import { collectStringLiteralsFromType, getStringProperty, hasTrueProperty, parseRouteConfigEntries, parseStringArray, } from './parser-support.mjs';
+import { hasPostDeclarationConfiguredObjectMutation } from './configured-object-mutations.mjs';
+export function parseStructuredTypeEntries(content, file, name, slugProperty, slugPluralProperty) {
+    const object = findConstObjectLiteral(content, name, file);
+    if (hasPostDeclarationConfiguredObjectMutation(content, file, name, object.end))
+        throw new Error(`${file}: ${name} has a post-declaration property mutation`);
+    const entries = [];
+    for (const property of object.properties) {
+        if (ts.isSpreadAssignment(property))
+            throw new Error(`${file}: ${name} contains an uninspectable spread`);
+        if (ts.isShorthandPropertyAssignment(property))
+            throw new Error(`${file}: ${name}.${property.name.text} must be an object literal`);
+        if (!ts.isPropertyAssignment(property))
+            continue;
+        const value = getPropertyNameText(property.name);
+        if (value === '__proto__' && !ts.isComputedPropertyName(property.name))
+            throw new Error(`${file}: ${name} contains unsupported __proto__ prototype setter`);
+        if (value === undefined)
+            continue;
+        const body = unwrapExpression(property.initializer);
+        if (!ts.isObjectLiteralExpression(body))
+            throw new Error(`${file}: ${name}.${value} must be an object literal`);
+        const names = new Set();
+        for (const member of body.properties) {
+            if (!ts.isPropertyAssignment(member))
+                throw new Error(`${file}: ${name}.${value} contains an uninspectable member`);
+            const memberName = getPropertyNameText(member.name);
+            if (!memberName || names.has(memberName))
+                throw new Error(`${file}: ${name}.${value} contains an uninspectable or duplicate key`);
+            names.add(memberName);
+        }
+        const slug = getStringProperty(body, slugProperty);
+        const slugPlural = getStringProperty(body, slugPluralProperty);
+        if (!slug)
+            throw new Error(`${file}: ${name}.${value} is missing ${slugProperty}`);
+        if (!slugPlural)
+            throw new Error(`${file}: ${name}.${value} is missing ${slugPluralProperty}`);
+        entries.push({ value, slug, slugPlural });
+    }
+    if (entries.length === 0)
+        throw new Error(`${file}: could not parse ${name} entries`);
+    return entries;
+}
+export function parseUnionSlugToType(content, file, name) {
+    const object = findConstObjectLiteral(content, name, file);
+    if (hasPostDeclarationConfiguredObjectMutation(content, file, name, object.end))
+        throw new Error(`${file}: ${name} has a post-declaration property mutation`);
+    const entries = new Map();
+    for (const property of object.properties) {
+        if (!ts.isPropertyAssignment(property))
+            throw new Error(`${file}: ${name} contains an uninspectable member`);
+        const key = getPropertyNameText(property.name);
+        if (!key)
+            throw new Error(`${file}: ${name} contains an uninspectable key`);
+        if (key === '__proto__' && !ts.isComputedPropertyName(property.name))
+            throw new Error(`${file}: ${name} contains unsupported __proto__ prototype setter`);
+        const value = getStringLiteralValue(property.initializer);
+        if (value === undefined)
+            throw new Error(`${file}: ${name}.${key} must be a string literal`);
+        entries.set(key, value);
+    }
+    if (entries.size === 0)
+        throw new Error(`${file}: could not parse ${name} entries`);
+    return entries;
+}
+export function parseUnionTypeUnion(content, file, name) {
+    const typeAlias = findTypeAliasDeclaration(content, name, file);
+    return collectStringLiteralsFromType(typeAlias.type);
+}
+export function parseUnionRouteConfigEntries(content, file, name, typeProperty, pluralPathProperty, singularPathProperty) {
+    return parseRouteConfigEntries(content, name, file, pluralPathProperty, singularPathProperty).map((entry) => ({
+        ...entry,
+        unionTypes: parseStringArray(entry.body, typeProperty, file),
+    }));
+}
+export function parseStructuredRouteConfigEntries(content, file, name, typeProperty, exemptionProperty, pluralPathProperty, singularPathProperty) {
+    return parseRouteConfigEntries(content, name, file, pluralPathProperty, singularPathProperty).map((entry) => ({
+        ...entry,
+        structuredTypes: parseStringArray(entry.body, typeProperty, file),
+        routeExempt: hasTrueProperty(entry.body, exemptionProperty),
+    }));
+}
+export function parseUnionDetailRouteFactoryArgs(content, file, callPattern) {
+    const args = [];
+    const matcher = new RegExp(callPattern.source, callPattern.flags);
+    for (const call of collectCallExpressions(content, file)) {
+        matcher.lastIndex = 0;
+        if (!matcher.test(getCallExpressionName(call.expression) ?? ''))
+            continue;
+        const unionType = getStringLiteralValue(call.arguments[0]);
+        const slug = getStringLiteralValue(call.arguments[1]);
+        if (unionType === undefined || slug === undefined)
+            throw new Error(`${file}: configured route factory call needs literal type and slug`);
+        args.push({ unionType, slug });
+    }
+    return args;
+}
+export function parseStructuredRouteFactoryArgs(content, file, callPattern) {
+    const args = [];
+    const matcher = new RegExp(callPattern.source, callPattern.flags);
+    for (const call of collectCallExpressions(content, file)) {
+        matcher.lastIndex = 0;
+        if (!matcher.test(getCallExpressionName(call.expression) ?? ''))
+            continue;
+        const slug = getStringLiteralValue(call.arguments[0]);
+        if (!slug)
+            throw new Error(`${file}: configured route factory call needs a string literal slug`);
+        args.push({ slug });
+    }
+    return args;
+}

package/dist/finite-enum-ripple/pattern-captures.d.mts

@@ -0,0 +1,2 @@
+/** Keep caller-supplied patterns while ignoring matches that begin in inactive source text. */
+export declare function collectActivePatternCaptures(content: string, pattern: RegExp, file: string): string[];

package/dist/finite-enum-ripple/pattern-captures.mjs

@@ -0,0 +1,45 @@
+import ts from '@typescript/typescript6';
+/** Keep caller-supplied patterns while ignoring matches that begin in inactive source text. */
+export function collectActivePatternCaptures(content, pattern, file) {
+    const astInactive = [];
+    const astLiterals = [];
+    const commentRanges = new Map();
+    const source = ts.createSourceFile(file, content, ts.ScriptTarget.Latest, true, file.endsWith('.tsx') || file.endsWith('.jsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const collectAstInactive = (node) => {
+        if (ts.isJsxText(node) || ts.isRegularExpressionLiteral(node))
+            astInactive.push({ start: node.getStart(source), end: node.end });
+        else if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node))
+            astLiterals.push({ start: node.getStart(source), end: node.end });
+        else if (node.kind === ts.SyntaxKind.TemplateHead ||
+            node.kind === ts.SyntaxKind.TemplateMiddle ||
+            node.kind === ts.SyntaxKind.TemplateTail)
+            astInactive.push({ start: node.getStart(source), end: node.end });
+        for (const range of [
+            ...(ts.getLeadingCommentRanges(content, node.getFullStart()) ?? []),
+            ...(ts.getTrailingCommentRanges(content, node.end) ?? []),
+        ])
+            commentRanges.set(`${range.pos}:${range.end}`, { start: range.pos, end: range.end });
+        ts.forEachChild(node, collectAstInactive);
+    };
+    collectAstInactive(source);
+    const inactive = [
+        ...[...commentRanges.values()]
+            .filter(({ start, end }) => !astInactive.some((span) => start < span.end && end > span.start))
+            .map(({ start, end }) => ({ start, end, literal: false })),
+        ...astInactive.map(({ start, end }) => ({ start, end, literal: false })),
+        ...astLiterals.map(({ start, end }) => ({ start, end, literal: true })),
+    ];
+    const flags = pattern.global ? pattern.flags : `${pattern.flags}g`;
+    const globalPattern = new RegExp(pattern.source, flags);
+    return [...content.matchAll(globalPattern)].flatMap((match) => {
+        if (inactive.some(({ start, end, literal }) => match.index >= start &&
+            match.index < end &&
+            !(literal && match.index === start) &&
+            !(literal &&
+                match.index === start + 1 &&
+                content[match.index] === '/' &&
+                match.index + match[0].length === end - 1)))
+            return [];
+        return match[1] === undefined ? [] : [match[1]];
+    });
+}

package/dist/finite-enum-ripple/structured-route-check.d.mts

@@ -0,0 +1,3 @@
+import type { FiniteEnumFiles, FiniteEnumRippleConfig, ReadTrackedFile } from './model.mts';
+import type { StructuredTypeEntry } from './parsers.mts';
+export declare function checkStructuredRouteConfigs(errors: string[], files: FiniteEnumFiles, readTracked: ReadTrackedFile, config: NonNullable<FiniteEnumRippleConfig['structured']>, backendEntries: StructuredTypeEntry[], backendSlugByValue: Map<string, string>): void;