@omnifyjp/ts 6.3.11 → 6.3.12

package/dist/php/index.js

@@ -35,7 +35,7 @@ import { generateControllers } from './controller-generator.js';
 import { generateServices } from './service-generator.js';
 import { generateRoutes } from './route-generator.js';
 import { generateEnums } from './enum-generator.js';
-import { normalizeNotOperator, normalizePhpBlankLines, normalizePhpStatements, normalizeTopLevelUses } from './php-style.js';
+import { normalizeFullyQualifiedClassRefs, normalizeNotOperator, normalizePhpBlankLines, normalizePhpStatements, normalizeTopLevelUses } from './php-style.js';
 import { generateOpenApi } from './openapi-generator.js';
 import { generateArchitectureDoc } from './architecture-doc-generator.js';
 export { derivePhpConfig } from './types.js';
@@ -116,6 +116,12 @@ export function generatePhp(data, overrides) {
     // unused imports dropped, the rest ordered. Doing it once, centrally, is why
     // no template has to remember: the two rules fired on almost every layer.
     return files.map((file) => file.path.endsWith('.php')
-        ? { ...file, content: normalizePhpBlankLines(normalizePhpStatements(normalizeNotOperator(normalizeTopLevelUses(file.content)))) }
+        ? {
+            ...file,
+            content: normalizePhpBlankLines(normalizePhpStatements(normalizeNotOperator(
+            // Hoist before ordering: the hoist adds imports the sort then
+            // puts in place, and the prune drops any it made redundant.
+            normalizeTopLevelUses(normalizeFullyQualifiedClassRefs(file.content))))),
+        }
         : file);
 }

package/dist/php/php-style.d.ts

@@ -81,3 +81,27 @@ export declare function normalizePhpStatements(content: string): string;
  * comparisons, not negations.
  */
 export declare function normalizeNotOperator(content: string): string;
+/**
+ * `fully_qualified_strict_types` with `import_symbols` — Pint's `laravel`
+ * preset turns an inline `\App\Models\Post::class` into a `use` plus the short
+ * name, in code and in docblock types alike.
+ *
+ * The generators write the FQN because it always resolves; Pint then rewrites
+ * it, and in a project of 146 schemas that was 193 files changing on every
+ * `generate` and changing back on every `pint` (reported after #174 fixed the
+ * Resource layer the same way — the remaining layers write FQNs from their own
+ * templates rather than through `createClassImporter`).
+ *
+ * Applied centrally, after the templates and before the import block is
+ * sorted, because the rule fires on every layer that names a class.
+ *
+ * What it leaves alone, because Pint does too:
+ *   - a class in this file's own namespace keeps just its short name, no
+ *     import — PHP resolves it already;
+ *   - a short name already bound to a different FQN keeps the FQN, since an
+ *     import would change which class the name means;
+ *   - a root-namespace `\Exception`, which has no namespace to import from;
+ *   - anything inside a string literal or a `//` comment: a morph-map value
+ *     `'App\Models\Post'` is data, not a reference.
+ */
+export declare function normalizeFullyQualifiedClassRefs(content: string): string;

package/dist/php/php-style.js

@@ -249,3 +249,155 @@ export function normalizeNotOperator(content) {
     }
     return out;
 }
+/**
+ * `fully_qualified_strict_types` with `import_symbols` — Pint's `laravel`
+ * preset turns an inline `\App\Models\Post::class` into a `use` plus the short
+ * name, in code and in docblock types alike.
+ *
+ * The generators write the FQN because it always resolves; Pint then rewrites
+ * it, and in a project of 146 schemas that was 193 files changing on every
+ * `generate` and changing back on every `pint` (reported after #174 fixed the
+ * Resource layer the same way — the remaining layers write FQNs from their own
+ * templates rather than through `createClassImporter`).
+ *
+ * Applied centrally, after the templates and before the import block is
+ * sorted, because the rule fires on every layer that names a class.
+ *
+ * What it leaves alone, because Pint does too:
+ *   - a class in this file's own namespace keeps just its short name, no
+ *     import — PHP resolves it already;
+ *   - a short name already bound to a different FQN keeps the FQN, since an
+ *     import would change which class the name means;
+ *   - a root-namespace `\Exception`, which has no namespace to import from;
+ *   - anything inside a string literal or a `//` comment: a morph-map value
+ *     `'App\Models\Post'` is data, not a reference.
+ */
+export function normalizeFullyQualifiedClassRefs(content) {
+    const nsMatch = content.match(/^namespace\s+([^;]+);/m);
+    const currentNamespace = nsMatch ? nsMatch[1].trim() : '';
+    // Seed with what the file already imports so a hoist cannot shadow one.
+    const bound = new Map();
+    // …and with the class this file declares. A Resource base named
+    // `DepartmentResource` that references the project's own
+    // `App\Http\Resources\DepartmentResource` must keep the FQN: importing a
+    // name the file already declares is a PHP fatal, not a style choice (#179).
+    const declared = content.match(/^(?:final\s+|abstract\s+)?(?:class|interface|trait|enum)\s+([A-Za-z0-9_]+)/m);
+    if (declared) {
+        bound.set(declared[1], currentNamespace ? `${currentNamespace}\\${declared[1]}` : declared[1]);
+    }
+    for (const line of content.split('\n')) {
+        if (/^(class|trait|interface|enum|abstract|final|return)\b/.test(line))
+            break;
+        const m = line.match(/^use\s+(?:function\s+|const\s+)?([^;]+);$/);
+        if (!m)
+            continue;
+        const spec = m[1].trim();
+        if (spec.includes(' as ')) {
+            bound.set(spec.slice(spec.lastIndexOf(' as ') + 4).trim(), spec.slice(0, spec.indexOf(' as ')).trim());
+            continue;
+        }
+        bound.set(spec.slice(spec.lastIndexOf('\\') + 1), spec);
+    }
+    const toImport = new Set();
+    // The leading `\` must start the reference: in `namespace App\Models\Base;`
+    // the inner `\Models\Base` is part of one name, not a reference to hoist.
+    const rewrite = (segment) => segment.replace(/(?<![\w\\])\\([A-Z][A-Za-z0-9_]*(?:\\[A-Z][A-Za-z0-9_]*)+)/g, (whole, fqn) => {
+        const shortName = fqn.slice(fqn.lastIndexOf('\\') + 1);
+        const ns = fqn.slice(0, fqn.lastIndexOf('\\'));
+        if (ns === currentNamespace)
+            return shortName;
+        const existing = bound.get(shortName);
+        if (existing && existing !== fqn)
+            return whole;
+        if (!existing)
+            bound.set(shortName, fqn);
+        toImport.add(fqn);
+        return shortName;
+    });
+    // Walk the file so strings and line comments keep their FQNs verbatim.
+    // Block comments are rewritten: that is where the docblock types live.
+    // Code accumulates in a buffer that is rewritten when flushed, so a `//`
+    // in the middle of a line is still recognised as a comment.
+    let out = '';
+    let code = '';
+    const flush = () => { out += rewrite(code); code = ''; };
+    let i = 0;
+    while (i < content.length) {
+        const ch = content[i];
+        const next = content[i + 1];
+        // A declaration names itself — rewriting it would rename the file's own
+        // namespace or eat an import.
+        if ((i === 0 || content[i - 1] === '\n')
+            && (content.startsWith('use ', i) || content.startsWith('namespace ', i))) {
+            flush();
+            const lineEnd = content.indexOf('\n', i);
+            const stop = lineEnd === -1 ? content.length : lineEnd + 1;
+            out += content.slice(i, stop);
+            i = stop;
+            continue;
+        }
+        if (ch === '/' && next === '/') {
+            flush();
+            const lineEnd = content.indexOf('\n', i);
+            const stop = lineEnd === -1 ? content.length : lineEnd;
+            out += content.slice(i, stop);
+            i = stop;
+            continue;
+        }
+        if (ch === '/' && next === '*') {
+            flush();
+            const end = content.indexOf('*/', i + 2);
+            const stop = end === -1 ? content.length : end + 2;
+            out += rewrite(content.slice(i, stop));
+            i = stop;
+            continue;
+        }
+        if (ch === "'" || ch === '"') {
+            flush();
+            const quote = ch;
+            let j = i + 1;
+            while (j < content.length) {
+                if (content[j] === '\\') {
+                    j += 2;
+                    continue;
+                }
+                if (content[j] === quote) {
+                    j++;
+                    break;
+                }
+                j++;
+            }
+            out += content.slice(i, j);
+            i = j;
+            continue;
+        }
+        code += ch;
+        i++;
+    }
+    flush();
+    if (toImport.size === 0)
+        return out;
+    const lines = out.split('\n');
+    let insertAt = -1;
+    for (let k = 0; k < lines.length; k++) {
+        if (/^use\s+[A-Za-z_\\][^;]*;\s*$/.test(lines[k])) {
+            insertAt = k;
+            break;
+        }
+        if (/^namespace\s+/.test(lines[k]))
+            insertAt = k + 1;
+        if (/^(class|trait|interface|enum|abstract|final|return)\b/.test(lines[k]))
+            break;
+    }
+    if (insertAt < 0)
+        return out;
+    const useLines = [...toImport].map((fqn) => `use ${fqn};`);
+    if (/^use\s+/.test(lines[insertAt] ?? '')) {
+        // Land inside the existing block; normalizeTopLevelUses orders it after.
+        lines.splice(insertAt, 0, ...useLines);
+    }
+    else {
+        lines.splice(insertAt, 0, '', ...useLines);
+    }
+    return lines.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "6.3.11",
+  "version": "6.3.12",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",