@rivinia/modal 0.6.0 → 0.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rivinia/modal",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "Headless modal manager for Angular: stack/queue strategies, typed results, guards, ownership.",
   "keywords": [
     "angular",
@@ -11,6 +11,7 @@
   ],
   "license": "MIT",
   "peerDependencies": {
+    "@angular-devkit/schematics": "^22.0.0",
     "@angular/common": "^22.0.0",
     "@angular/core": "^22.0.0"
   },

package/schematics/ng-add/index.cjs

@@ -34,7 +34,7 @@ function ngAdd(options) {
         }
         const provideCall = options.strategy !== undefined ? `provideRiviniaModal({ strategy: '${options.strategy}' })` : 'provideRiviniaModal()';
         let changed = false;
-        if (!content.includes(PROVIDE_IMPORT)) {
+        if (!importsValue(content, '@rivinia/modal', 'provideRiviniaModal')) {
             content = insertAfterLastImport(content, PROVIDE_IMPORT);
             changed = true;
         }
@@ -99,3 +99,33 @@ function insertProvider(content, call) {
     const at = match.index + match[0].length;
     return `${content.slice(0, at)}\n    ${call},${content.slice(at)}`;
 }
+/**
+ * Whether the file already binds `symbol` as a VALUE imported from `module`.
+ *
+ * A plain `content.includes(IMPORT_LINE)` recognises only ONE shape of the
+ * import — `import { symbol } from 'module';`. An app that imports the
+ * symbol beside others (`import { other, symbol } from 'module';`) would be
+ * given a SECOND import of the same symbol, and its build would then fail
+ * with "Duplicate identifier" (TS2300).
+ *
+ * An aliased or a type-only import does not bind the name we need, so it
+ * does not count as present.
+ */
+function importsValue(content, module, symbol) {
+    const pattern = /import\s+(?:type\s+)?\{([^}]*)\}\s*from\s*['"]([^'"]+)['"]/g;
+    for (const match of content.matchAll(pattern)) {
+        if (match[2] !== module)
+            continue;
+        if (/^\s*import\s+type\s/.test(match[0]))
+            continue; // a type-only import
+        for (const entry of match[1].split(',')) {
+            const raw = entry.trim();
+            if (!raw || /^type\s/.test(raw))
+                continue; // a type-only specifier
+            const local = raw.split(/\s+as\s+/).pop().trim();
+            if (local === symbol)
+                return true;
+        }
+    }
+    return false;
+}