@skmtc/core 0.28.7 → 0.29.0

package/esm/context/GenerateContext.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _GenerateContext_instances, _GenerateContext_files, _GenerateContext_previews, _GenerateContext_captureChannel, _GenerateContext_enrichmentAudit, _GenerateContext_reportSkippedEnrichment, _GenerateContext_schemaRefNames, _GenerateContext_subjectDefaults, _GenerateContext_runOasOperationGenerator, _GenerateContext_runWebhookGenerator, _GenerateContext_runGqlOperationGenerator, _GenerateContext_runModelGenerator, _GenerateContext_addPreview, _GenerateContext_toContentSettingsExportPath, _GenerateContext_ejectedBySuffixedPath_get, _GenerateContext_ejectedBySuffixedPathCache, _GenerateContext_findContainer, _GenerateContext_toContainer;
-import { normalize } from '../deps/jsr.io/@std/path/1.1.6/normalize.js';
+import { normalizeWorkspacePath } from '../helpers/normalizeWorkspacePath.js';
 import { applyGeneratedSuffix, DEFAULT_GENERATED_SUFFIX } from '../helpers/applyGeneratedSuffix.js';
 import { OasOperationDriver } from '../dsl/operation/oas/OasOperationDriver.js';
 import { WebhookDriver } from '../dsl/webhook/WebhookDriver.js';
@@ -443,7 +443,7 @@ export class GenerateContext {
      * language-constructed file, use {@link addFile}.
      */
     getFile(filePath) {
-        return __classPrivateFieldGet(this, _GenerateContext_files, "f").get(normalize(filePath));
+        return __classPrivateFieldGet(this, _GenerateContext_files, "f").get(normalizeWorkspacePath(filePath));
     }
     /**
      * Read-only view of every file generated so far, keyed by (normalized)
@@ -467,7 +467,7 @@ export class GenerateContext {
      * (`context.getFile(path) ?? context.addFile(new KtFile({ … }))`).
      */
     addFile(file) {
-        const normalizedPath = normalize(file.path);
+        const normalizedPath = normalizeWorkspacePath(file.path);
         if (__classPrivateFieldGet(this, _GenerateContext_files, "f").has(normalizedPath)) {
             throw new Error(`File already exists: ${normalizedPath}`);
         }
@@ -481,7 +481,7 @@ export class GenerateContext {
      * @param args - Registration arguments with destination path and JSON content
      */
     registerJson({ destinationPath, json }) {
-        const normalizedPath = normalize(destinationPath);
+        const normalizedPath = normalizeWorkspacePath(destinationPath);
         let currentFile = this.getFile(normalizedPath);
         if (!currentFile) {
             currentFile = new JsonFile({ path: normalizedPath, content: {} });
@@ -500,7 +500,7 @@ export class GenerateContext {
      * @experimental This method is experimental and may change in future versions
      */
     registerMarkdown({ destinationPath, markdown }) {
-        const normalizedPath = normalize(destinationPath);
+        const normalizedPath = normalizeWorkspacePath(destinationPath);
         let currentFile = this.getFile(normalizedPath);
         if (!currentFile) {
             currentFile = new MarkdownFile({ path: normalizedPath, content: '' });
@@ -521,7 +521,7 @@ export class GenerateContext {
      * @mutates this.files
      */
     register({ imports = [], reExports = [], definitions, custom, destinationPath, into }) {
-        const normalizedPath = normalize(destinationPath);
+        const normalizedPath = normalizeWorkspacePath(destinationPath);
         const currentFile = this.getFile(normalizedPath);
         // `register` never creates files — it speaks pure data and the engine
         // never names a file class. Callers pre-create the destination file
@@ -629,7 +629,7 @@ export class GenerateContext {
         // the use site (same ephemeral read the Drivers make) — pre-creates
         // the destination file caller-side, and stores via the pure-data
         // `register`.
-        const normalizedPath = normalize(destinationPath);
+        const normalizedPath = normalizeWorkspacePath(destinationPath);
         if (!this.getFile(normalizedPath)) {
             this.addFile(projection.lang.createFile({ path: normalizedPath, settings: this.settings }));
         }
@@ -696,7 +696,7 @@ export class GenerateContext {
                     enrichments,
                     variant,
                     options
-                })),
+                }), args.projection.id),
                 enrichments,
                 variant
             });
@@ -724,7 +724,7 @@ export class GenerateContext {
                     enrichments,
                     variant,
                     options
-                })),
+                }), args.projection.id),
             enrichments,
             variant
         });
@@ -757,7 +757,7 @@ export class GenerateContext {
                 enrichments,
                 variant,
                 options
-            })),
+            }), args.projection.id),
             enrichments,
             variant
         });
@@ -779,7 +779,7 @@ export class GenerateContext {
                 name: projection.toIdentifierName({ refName, enrichments, variant, options }),
                 ...projection.toIdentifierType(refName, this)
             }),
-            exportPath: __classPrivateFieldGet(this, _GenerateContext_instances, "m", _GenerateContext_toContentSettingsExportPath).call(this, projection.toExportPath({ refName, enrichments, variant, options })),
+            exportPath: __classPrivateFieldGet(this, _GenerateContext_instances, "m", _GenerateContext_toContentSettingsExportPath).call(this, projection.toExportPath({ refName, enrichments, variant, options }), projection.id),
             enrichments,
             variant
         });
@@ -1165,15 +1165,15 @@ _GenerateContext_files = new WeakMap(), _GenerateContext_previews = new WeakMap(
         module: { ...module, exportPath: __classPrivateFieldGet(this, _GenerateContext_instances, "m", _GenerateContext_toContentSettingsExportPath).call(this, module.exportPath) },
         source
     };
-}, _GenerateContext_toContentSettingsExportPath = function _GenerateContext_toContentSettingsExportPath(exportPath) {
-    const suffixed = applyGeneratedSuffix(exportPath, this.settings?.generatedSuffix ?? DEFAULT_GENERATED_SUFFIX);
-    return __classPrivateFieldGet(this, _GenerateContext_instances, "a", _GenerateContext_ejectedBySuffixedPath_get).get(normalize(suffixed)) ?? suffixed;
+}, _GenerateContext_toContentSettingsExportPath = function _GenerateContext_toContentSettingsExportPath(exportPath, generatorId) {
+    const suffixed = applyGeneratedSuffix(normalizeWorkspacePath(exportPath, { generatorId }), this.settings?.generatedSuffix ?? DEFAULT_GENERATED_SUFFIX);
+    return __classPrivateFieldGet(this, _GenerateContext_instances, "a", _GenerateContext_ejectedBySuffixedPath_get).get(suffixed) ?? suffixed;
 }, _GenerateContext_ejectedBySuffixedPath_get = function _GenerateContext_ejectedBySuffixedPath_get() {
     if (__classPrivateFieldGet(this, _GenerateContext_ejectedBySuffixedPathCache, "f") === undefined) {
         const suffix = this.settings?.generatedSuffix ?? DEFAULT_GENERATED_SUFFIX;
         __classPrivateFieldSet(this, _GenerateContext_ejectedBySuffixedPathCache, new Map((this.settings?.ejected ?? []).map(ejectedPath => {
-            const normalized = normalize(ejectedPath);
-            return [normalize(applyGeneratedSuffix(normalized, suffix)), normalized];
+            const normalized = normalizeWorkspacePath(ejectedPath);
+            return [applyGeneratedSuffix(normalized, suffix), normalized];
         })), "f");
     }
     return __classPrivateFieldGet(this, _GenerateContext_ejectedBySuffixedPathCache, "f");

package/esm/context/RenderContext.d.ts

@@ -130,13 +130,13 @@ export declare class RenderContext {
      */
     collate(stackTrail: StackTrail): FilesRenderResult;
     /**
-     * Retrieves a file from the context by its normalized path.
+     * Retrieves a file from the context by its export path.
      *
-     * This method looks up a file in the context's file map using path normalization
-     * to ensure consistent path resolution. It validates that the requested file
-     * exists and throws an error if not found.
+     * The path is canonicalized first ({@link normalizeWorkspacePath}), so any
+     * spelling of the same export path finds the same file. Throws when no
+     * file exists at that path.
      *
-     * @param filePath - The file path to retrieve (will be normalized)
+     * @param filePath - The export path to retrieve, in any spelling
      * @returns The File or JsonFile instance
      * @throws {Error} When the file is not found in the context
      *
@@ -145,9 +145,9 @@ export declare class RenderContext {
      * const file = renderContext.getFile('./src/models/User.ts');
      * console.log(file.toString()); // Access file content
      *
-     * // Works with various path formats
+     * // Every spelling of the same export path finds the same file
      * const sameFile = renderContext.getFile('src/models/User.ts');
-     * const alsoSameFile = renderContext.getFile('/absolute/path/src/models/User.ts');
+     * const alsoSameFile = renderContext.getFile('@/src/models/User.ts');
      * ```
      */
     getFile(filePath: string): FileBase;

package/esm/context/RenderContext.js

@@ -11,7 +11,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 };
 var _RenderContext_captureChannel, _RenderContext_sink, _RenderContext_captures;
 import invariant from 'tiny-invariant';
-import { normalize } from '../deps/jsr.io/@std/path/1.1.6/normalize.js';
+import { normalizeWorkspacePath } from '../helpers/normalizeWorkspacePath.js';
 import { toResolvedArtifactPath } from '../helpers/toResolvedArtifactPath.js';
 import { CodeFileBase } from '../dsl/CodeFileBase.js';
 import { CaptureSink } from '../anchors/CaptureSink.js';
@@ -168,8 +168,9 @@ export class RenderContext {
             __classPrivateFieldSet(this, _RenderContext_sink, undefined, "f");
         }
         // Build one sidecar per captured File from the spans the sink
-        // resolved (no re-render, no `toString`). Keyed by destination path,
-        // matching the file map. Accumulate the flat generation map.
+        // resolved (no re-render, no `toString`). Keyed by the resolved artifact
+        // path, matching `artifacts` and the manifest, so a sidecar sits at
+        // `<outDir>/<artifact key>.skm.json` where doctor looks for it.
         const { parser, schemaSrc, generatorMeta } = postPassConfig;
         const sidecars = {};
         const generationMap = [];
@@ -182,7 +183,11 @@ export class RenderContext {
                 parser,
                 generatorMeta
             });
-            sidecars[capture.destinationPath] = sidecar;
+            const artifactPath = toResolvedArtifactPath({
+                basePath: this.basePath,
+                destinationPath: capture.destinationPath
+            });
+            sidecars[artifactPath] = sidecar;
             generationMap.push(...entriesForSidecar(sidecar));
         }
         __classPrivateFieldSet(this, _RenderContext_captures, [], "f");
@@ -270,13 +275,13 @@ export class RenderContext {
         return output;
     }
     /**
-     * Retrieves a file from the context by its normalized path.
+     * Retrieves a file from the context by its export path.
      *
-     * This method looks up a file in the context's file map using path normalization
-     * to ensure consistent path resolution. It validates that the requested file
-     * exists and throws an error if not found.
+     * The path is canonicalized first ({@link normalizeWorkspacePath}), so any
+     * spelling of the same export path finds the same file. Throws when no
+     * file exists at that path.
      *
-     * @param filePath - The file path to retrieve (will be normalized)
+     * @param filePath - The export path to retrieve, in any spelling
      * @returns The File or JsonFile instance
      * @throws {Error} When the file is not found in the context
      *
@@ -285,13 +290,13 @@ export class RenderContext {
      * const file = renderContext.getFile('./src/models/User.ts');
      * console.log(file.toString()); // Access file content
      *
-     * // Works with various path formats
+     * // Every spelling of the same export path finds the same file
      * const sameFile = renderContext.getFile('src/models/User.ts');
-     * const alsoSameFile = renderContext.getFile('/absolute/path/src/models/User.ts');
+     * const alsoSameFile = renderContext.getFile('@/src/models/User.ts');
      * ```
      */
     getFile(filePath) {
-        const normalizedPath = normalize(filePath);
+        const normalizedPath = normalizeWorkspacePath(filePath);
         const currentFile = this.files.get(normalizedPath);
         invariant(currentFile, `File not found during render phase: ${normalizedPath}`);
         return currentFile;

package/esm/deps/jsr.io/@std/path/1.1.6/posix/is_absolute.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Verifies whether provided path is absolute.
+ *
+ * @example Usage
+ * ```ts
+ * import { isAbsolute } from "@std/path/posix/is-absolute";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(isAbsolute("/home/user/Documents/"));
+ * assertFalse(isAbsolute("home/user/Documents/"));
+ * ```
+ *
+ * @param path The path to verify.
+ * @returns Whether the path is absolute.
+ */
+export declare function isAbsolute(path: string): boolean;

package/esm/deps/jsr.io/@std/path/1.1.6/posix/is_absolute.js

@@ -0,0 +1,23 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { assertPath } from "../_common/assert_path.js";
+import { isPosixPathSeparator } from "./_util.js";
+/**
+ * Verifies whether provided path is absolute.
+ *
+ * @example Usage
+ * ```ts
+ * import { isAbsolute } from "@std/path/posix/is-absolute";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(isAbsolute("/home/user/Documents/"));
+ * assertFalse(isAbsolute("home/user/Documents/"));
+ * ```
+ *
+ * @param path The path to verify.
+ * @returns Whether the path is absolute.
+ */
+export function isAbsolute(path) {
+    assertPath(path);
+    return path.length > 0 && isPosixPathSeparator(path.charCodeAt(0));
+}

package/esm/deps/jsr.io/@std/path/1.1.6/windows/is_absolute.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Verifies whether provided path is absolute.
+ *
+ * @example Usage
+ * ```ts
+ * import { isAbsolute } from "@std/path/windows/is-absolute";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(isAbsolute("C:\\foo\\bar"));
+ * assertFalse(isAbsolute("..\\baz"));
+ * ```
+ *
+ * @param path The path to verify.
+ * @returns `true` if the path is absolute, `false` otherwise.
+ */
+export declare function isAbsolute(path: string): boolean;

package/esm/deps/jsr.io/@std/path/1.1.6/windows/is_absolute.js

@@ -0,0 +1,38 @@
+// Copyright 2018-2026 the Deno authors. MIT license.
+// This module is browser compatible.
+import { CHAR_COLON } from "../_common/constants.js";
+import { assertPath } from "../_common/assert_path.js";
+import { isPathSeparator, isWindowsDeviceRoot } from "./_util.js";
+/**
+ * Verifies whether provided path is absolute.
+ *
+ * @example Usage
+ * ```ts
+ * import { isAbsolute } from "@std/path/windows/is-absolute";
+ * import { assert, assertFalse } from "@std/assert";
+ *
+ * assert(isAbsolute("C:\\foo\\bar"));
+ * assertFalse(isAbsolute("..\\baz"));
+ * ```
+ *
+ * @param path The path to verify.
+ * @returns `true` if the path is absolute, `false` otherwise.
+ */
+export function isAbsolute(path) {
+    assertPath(path);
+    const len = path.length;
+    if (len === 0)
+        return false;
+    const code = path.charCodeAt(0);
+    if (isPathSeparator(code)) {
+        return true;
+    }
+    else if (isWindowsDeviceRoot(code)) {
+        // Possible device root
+        if (len > 2 && path.charCodeAt(1) === CHAR_COLON) {
+            if (isPathSeparator(path.charCodeAt(2)))
+                return true;
+        }
+    }
+    return false;
+}

package/esm/dsl/model/ModelDriver.js

@@ -1,4 +1,4 @@
-import { normalize } from '../../deps/jsr.io/@std/path/1.1.6/normalize.js';
+import { normalizeWorkspacePath } from '../../helpers/normalizeWorkspacePath.js';
 import { toModelGeneratorKey } from '../GeneratorKeys.js';
 import { DEFAULT_VARIANT } from '../../types/Variant.js';
 import { readProjectionOptions, toValueOptions } from '../../types/ProjectionOptions.js';
@@ -104,7 +104,8 @@ export class ModelDriver {
     apply({ destinationPath } = {}) {
         const { identifier, exportPath } = this.settings;
         const definition = this.getDefinition({ identifier, exportPath });
-        if (destinationPath && normalize(exportPath) !== normalize(destinationPath)) {
+        if (destinationPath &&
+            normalizeWorkspacePath(exportPath) !== normalizeWorkspacePath(destinationPath)) {
             // Cross-file import of the peer's identifier from its export path.
             // The language builds the import object (`toImport`) and creates the
             // destination file on first write (caller-side); the engine stores
@@ -124,7 +125,7 @@ export class ModelDriver {
      * cache-hit path). Returns the normalized path.
      */
     ensureFile(path) {
-        const normalizedPath = normalize(path);
+        const normalizedPath = normalizeWorkspacePath(path);
         if (!this.context.getFile(normalizedPath)) {
             this.context.addFile(this.projection.lang.createFile({ path: normalizedPath, settings: this.context.settings }));
         }

package/esm/dsl/operation/gql/GqlOperationDriver.js

@@ -1,4 +1,4 @@
-import { normalize } from '../../../deps/jsr.io/@std/path/1.1.6/normalize.js';
+import { normalizeWorkspacePath } from '../../../helpers/normalizeWorkspacePath.js';
 import { toGqlOperationGeneratorKey } from '../../GeneratorKeys.js';
 import { DEFAULT_VARIANT } from '../../../types/Variant.js';
 import { readProjectionOptions, toValueOptions } from '../../../types/ProjectionOptions.js';
@@ -95,7 +95,8 @@ export class GqlOperationDriver {
     apply({ destinationPath } = {}) {
         const { identifier, exportPath } = this.settings;
         const definition = this.getDefinition({ identifier, exportPath });
-        if (destinationPath && normalize(exportPath) !== normalize(destinationPath)) {
+        if (destinationPath &&
+            normalizeWorkspacePath(exportPath) !== normalizeWorkspacePath(destinationPath)) {
             // Cross-file import of the peer's identifier from its export path.
             // The language builds the import object (`toImport`) and creates the
             // destination file on first write (caller-side); the engine stores
@@ -117,7 +118,7 @@ export class GqlOperationDriver {
      * cache-hit path). Returns the normalized path.
      */
     ensureFile(path) {
-        const normalizedPath = normalize(path);
+        const normalizedPath = normalizeWorkspacePath(path);
         if (!this.context.getFile(normalizedPath)) {
             this.context.addFile(this.projection.lang.createFile({ path: normalizedPath, settings: this.context.settings }));
         }

package/esm/dsl/operation/oas/OasOperationDriver.js

@@ -10,7 +10,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _OasOperationDriver_into;
-import { normalize } from '../../../deps/jsr.io/@std/path/1.1.6/normalize.js';
+import { normalizeWorkspacePath } from '../../../helpers/normalizeWorkspacePath.js';
 import invariant from 'tiny-invariant';
 import { toOasOperationGeneratorKey } from '../../GeneratorKeys.js';
 import { DEFAULT_VARIANT } from '../../../types/Variant.js';
@@ -134,7 +134,8 @@ export class OasOperationDriver {
         const { identifier, exportPath } = this.settings;
         // The file an import has to be stitched into, or `undefined` when there
         // is none to stitch — no destination, or the projection's own file.
-        const importInto = destinationPath && normalize(exportPath) !== normalize(destinationPath)
+        const importInto = destinationPath &&
+            normalizeWorkspacePath(exportPath) !== normalizeWorkspacePath(destinationPath)
             ? destinationPath
             : undefined;
         // A member is declared inside its container, so it has no module-level
@@ -168,7 +169,7 @@ export class OasOperationDriver {
      * cache-hit path). Returns the normalized path.
      */
     ensureFile(path) {
-        const normalizedPath = normalize(path);
+        const normalizedPath = normalizeWorkspacePath(path);
         if (!this.context.getFile(normalizedPath)) {
             this.context.addFile(this.projection.lang.createFile({ path: normalizedPath, settings: this.context.settings }));
         }

package/esm/dsl/webhook/WebhookDriver.js

@@ -1,4 +1,4 @@
-import { normalize } from '../../deps/jsr.io/@std/path/1.1.6/normalize.js';
+import { normalizeWorkspacePath } from '../../helpers/normalizeWorkspacePath.js';
 import { toWebhookGeneratorKey } from '../GeneratorKeys.js';
 import { DEFAULT_VARIANT } from '../../types/Variant.js';
 import { readProjectionOptions, toValueOptions } from '../../types/ProjectionOptions.js';
@@ -95,7 +95,8 @@ export class WebhookDriver {
     apply({ destinationPath } = {}) {
         const { identifier, exportPath } = this.settings;
         const definition = this.getDefinition({ identifier, exportPath });
-        if (destinationPath && normalize(exportPath) !== normalize(destinationPath)) {
+        if (destinationPath &&
+            normalizeWorkspacePath(exportPath) !== normalizeWorkspacePath(destinationPath)) {
             // Cross-file import of the peer's identifier from its export path.
             this.ensureFile(destinationPath);
             this.context.register({
@@ -110,7 +111,7 @@ export class WebhookDriver {
      * projection's language. Returns the normalized path.
      */
     ensureFile(path) {
-        const normalizedPath = normalize(path);
+        const normalizedPath = normalizeWorkspacePath(path);
         if (!this.context.getFile(normalizedPath)) {
             this.context.addFile(this.projection.lang.createFile({ path: normalizedPath, settings: this.context.settings }));
         }

package/esm/helpers/applyGeneratedSuffix.js

@@ -1,4 +1,4 @@
-import { extname } from '../deps/jsr.io/@std/path/1.1.6/extname.js';
+import { extname } from '../deps/jsr.io/@std/path/1.1.6/posix/extname.js';
 /**
  * The filename suffix marking a file as engine-owned, applied by the
  * engine when a projection's `toExportPath` result is stored into

package/esm/helpers/isImported.d.ts

@@ -1,81 +1,17 @@
 /**
- * Determines whether two file paths represent different locations (import required).
+ * Whether two workspace paths name different files, so a symbol from one
+ * must be imported into the other.
  *
- * This utility function normalizes two file paths and compares them to determine
- * if they represent different files. It's used throughout the SKMTC system to
- * decide when import statements are needed - if two paths are different, an
- * import is required to access symbols from one file in another.
+ * Both are canonicalized with {@link normalizeWorkspacePath}, so every
+ * spelling of one file compares equal: `@/`, `./`, the bare form, and
+ * Windows separators. Throws, as that does, for a path that cannot name a
+ * file below `basePath` (a `..` segment, a Windows drive path).
  *
- * The function handles path normalization to ensure consistent comparisons
- * across different operating systems and path formats (handling './' vs absolute
- * paths, different separators, etc.).
- *
- * @param pathOne - The first file path to compare
- * @param pathTwo - The second file path to compare
- * @returns `true` if the paths are different (import needed), `false` if they're the same file
- *
- * @example Basic path comparison
- * ```typescript
- * import { isImported } from '@skmtc/core';
- *
- * // Same file, no import needed
- * console.log(isImported('./src/user.ts', './src/user.ts')); // false
- *
- * // Different files, import needed
- * console.log(isImported('./src/user.ts', './src/product.ts')); // true
- * ```
- *
- * @example Path normalization handling
- * ```typescript
- * // These all represent the same file after normalization
- * console.log(isImported('./src/user.ts', 'src/user.ts')); // false
- * console.log(isImported('src/./user.ts', 'src/user.ts')); // false
- * console.log(isImported('src/models/../user.ts', 'src/user.ts')); // false
- * ```
- *
- * @example Usage in import decision logic
+ * @example
  * ```typescript
- * class FileGenerator {
- *   addImportIfNeeded(
- *     sourceFile: string,
- *     targetFile: string,
- *     importName: string
- *   ) {
- *     if (isImported(sourceFile, targetFile)) {
- *       // Files are different, add import
- *       this.addImport(sourceFile, targetFile, importName);
- *       console.log(`Added import: ${importName} from ${targetFile}`);
- *     } else {
- *       // Same file, no import needed
- *       console.log(`No import needed - same file: ${sourceFile}`);
- *     }
- *   }
- * }
- * ```
- *
- * @example Cross-platform path handling
- * ```typescript
- * // Works consistently across platforms
- * const windowsPath = 'src\\models\\user.ts';
- * const unixPath = 'src/models/user.ts';
- *
- * console.log(isImported(windowsPath, unixPath)); // false (same file)
- * ```
- *
- * @example In generator context
- * ```typescript
- * class ModelGenerator {
- *   generateModel(modelPath: string, referencePath: string) {
- *     const definition = this.createModelDefinition();
- *
- *     if (isImported(modelPath, referencePath)) {
- *       // Need to import the referenced model
- *       definition.addImport(referencePath, 'ReferencedModel');
- *     }
- *
- *     return definition;
- *   }
- * }
+ * isImported('@/src/user.ts', './src/user.ts')    // false — one file
+ * isImported('src\\user.ts', 'src/user.ts')       // false — one file
+ * isImported('@/src/user.ts', '@/src/product.ts') // true
  * ```
  */
 export declare const isImported: (pathOne: string, pathTwo: string) => boolean;

package/esm/helpers/isImported.js

@@ -1,84 +1,20 @@
-import { normalize } from '../deps/jsr.io/@std/path/1.1.6/normalize.js';
+import { normalizeWorkspacePath } from './normalizeWorkspacePath.js';
 /**
- * Determines whether two file paths represent different locations (import required).
+ * Whether two workspace paths name different files, so a symbol from one
+ * must be imported into the other.
  *
- * This utility function normalizes two file paths and compares them to determine
- * if they represent different files. It's used throughout the SKMTC system to
- * decide when import statements are needed - if two paths are different, an
- * import is required to access symbols from one file in another.
+ * Both are canonicalized with {@link normalizeWorkspacePath}, so every
+ * spelling of one file compares equal: `@/`, `./`, the bare form, and
+ * Windows separators. Throws, as that does, for a path that cannot name a
+ * file below `basePath` (a `..` segment, a Windows drive path).
  *
- * The function handles path normalization to ensure consistent comparisons
- * across different operating systems and path formats (handling './' vs absolute
- * paths, different separators, etc.).
- *
- * @param pathOne - The first file path to compare
- * @param pathTwo - The second file path to compare
- * @returns `true` if the paths are different (import needed), `false` if they're the same file
- *
- * @example Basic path comparison
- * ```typescript
- * import { isImported } from '@skmtc/core';
- *
- * // Same file, no import needed
- * console.log(isImported('./src/user.ts', './src/user.ts')); // false
- *
- * // Different files, import needed
- * console.log(isImported('./src/user.ts', './src/product.ts')); // true
- * ```
- *
- * @example Path normalization handling
- * ```typescript
- * // These all represent the same file after normalization
- * console.log(isImported('./src/user.ts', 'src/user.ts')); // false
- * console.log(isImported('src/./user.ts', 'src/user.ts')); // false
- * console.log(isImported('src/models/../user.ts', 'src/user.ts')); // false
- * ```
- *
- * @example Usage in import decision logic
+ * @example
  * ```typescript
- * class FileGenerator {
- *   addImportIfNeeded(
- *     sourceFile: string,
- *     targetFile: string,
- *     importName: string
- *   ) {
- *     if (isImported(sourceFile, targetFile)) {
- *       // Files are different, add import
- *       this.addImport(sourceFile, targetFile, importName);
- *       console.log(`Added import: ${importName} from ${targetFile}`);
- *     } else {
- *       // Same file, no import needed
- *       console.log(`No import needed - same file: ${sourceFile}`);
- *     }
- *   }
- * }
- * ```
- *
- * @example Cross-platform path handling
- * ```typescript
- * // Works consistently across platforms
- * const windowsPath = 'src\\models\\user.ts';
- * const unixPath = 'src/models/user.ts';
- *
- * console.log(isImported(windowsPath, unixPath)); // false (same file)
- * ```
- *
- * @example In generator context
- * ```typescript
- * class ModelGenerator {
- *   generateModel(modelPath: string, referencePath: string) {
- *     const definition = this.createModelDefinition();
- *
- *     if (isImported(modelPath, referencePath)) {
- *       // Need to import the referenced model
- *       definition.addImport(referencePath, 'ReferencedModel');
- *     }
- *
- *     return definition;
- *   }
- * }
+ * isImported('@/src/user.ts', './src/user.ts')    // false — one file
+ * isImported('src\\user.ts', 'src/user.ts')       // false — one file
+ * isImported('@/src/user.ts', '@/src/product.ts') // true
  * ```
  */
 export const isImported = (pathOne, pathTwo) => {
-    return normalize(pathOne) !== normalize(pathTwo);
+    return normalizeWorkspacePath(pathOne) !== normalizeWorkspacePath(pathTwo);
 };