@iqual/nuxt-icms 1.6.0-rc.3 → 1.6.0-rc.5

package/components/Drupal/Webform/index.vue

@@ -8,10 +8,10 @@
       @error="console.log"
       noValidate
     >
-      
-      <DesignSystemAtomsButton 
-        v-if="debug" 
-        @click="console.log(schema.safeParse(state))""
+
+      <DesignSystemAtomsButton
+        v-if="debug"
+        @click="console.log(schema.safeParse(state))"
         label="Debug Schema"
       />
 
@@ -24,7 +24,7 @@
           v-model="token"
           v-if="formElement?.metadata?.key === 'actions'"
         /> -->
-        
+
         <component
           v-if="formElement?.metadata?.type"
           :is="getComponent(formElement?.metadata?.type)"
@@ -34,8 +34,8 @@
           :debug="debug"
         />
       </div>
-      <DesignSystemAtomsButton 
-        v-if="debug" 
+      <DesignSystemAtomsButton
+        v-if="debug"
         @click="console.log(schema.safeParse(state))"
         label="Debug Schema"
         :buttonStyle="'focus'"

package/config/blokkli.ts

@@ -72,6 +72,7 @@ export default defineNuxtConfigProperty<'blokkli'>((ctx) => {
     },
     pattern: [
       './components/Paragraph/**/*.{js,ts,vue}',
+      './components/Blokkli/**/*.{js,ts,vue}',
       join(currentLayerDir, './components/Blokkli/**/*.{js,ts,vue}'),
     ],
     globalOptions: {
@@ -385,4 +386,4 @@ export default defineNuxtConfigProperty<'blokkli'>((ctx) => {
     // current page language.
     forceDefaultLanguage: false,
   }
-})
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iqual/nuxt-icms",
-  "version": "1.6.0-rc.3",
+  "version": "1.6.0-rc.5",
   "description": "ICMS Base",
   "type": "module",
   "private": false,
@@ -32,7 +32,7 @@
     "nitropack": "~2.13.4",
     "nuxt": "~4.4.8",
     "nuxt-easy-texts": "~2.1.2",
-    "nuxt-graphql-middleware": "~5.4.0",
+    "nuxt-graphql-middleware": "5.4.0",
     "nuxt-language-negotiation": "~2.0.2",
     "nuxt-maplibre": "~1.2.2",
     "nuxt-multi-cache": "~4.0.3",

package/patches/@blokkli+editor+2.0.0-alpha.13.patch

@@ -0,0 +1,164 @@
+diff --git a/node_modules/@blokkli/editor/dist/module.mjs b/node_modules/@blokkli/editor/dist/module.mjs
+index 0ff0d3b..5329e9f 100644
+--- a/node_modules/@blokkli/editor/dist/module.mjs
++++ b/node_modules/@blokkli/editor/dist/module.mjs
+@@ -271,16 +271,31 @@ class CollectedBlockFile extends CollectedFile {
+ }
+ class BlockCollector extends Collector {
+   patterns;
++  positivePatterns;
++  negativePatterns;
++  // Files that define the same block bundle (or fragment name) as a file in a
++  // higher-priority Nuxt layer. They are kept here instead of in `files` so
++  // they can be re-activated when the overriding file is removed.
++  shadowed = /* @__PURE__ */ new Map();
+   constructor(helper) {
+     super(helper);
+-    this.patterns = (helper.options.pattern || []).map((pattern) => {
++    this.patterns = (helper.options.pattern || []).map((raw) => {
++      // Support negated glob patterns (e.g. "!**/components/Blokkli/Text/**")
++      // to exclude components from collection.
++      const isNegated = raw.startsWith("!");
++      const pattern = isNegated ? raw.slice(1) : raw;
++      let resolved = pattern;
+       if (pattern.startsWith("/")) {
+-        return pattern;
++        resolved = pattern;
+       } else if (pattern.startsWith(".")) {
+-        return helper.resolvers.src.resolve(pattern);
++        resolved = helper.resolvers.src.resolve(pattern);
++      } else {
++        resolved = resolveAlias(pattern);
+       }
+-      return resolveAlias(pattern);
++      return isNegated ? "!" + resolved : resolved;
+     });
++    this.positivePatterns = this.patterns.filter((v) => !v.startsWith("!"));
++    this.negativePatterns = this.patterns.filter((v) => v.startsWith("!")).map((v) => v.slice(1));
+   }
+   async init() {
+     const files = await resolveFiles(
+@@ -295,6 +310,90 @@ class BlockCollector extends Collector {
+       }
+     }
+     await Promise.all(promises);
++    this.resolveLayerOverrides();
++  }
++  /**
++   * Determine the Nuxt layer priority of a file.
++   *
++   * Lower value = higher priority. The app/project layer is index 0, extended
++   * layers follow in the order they are defined. Files that can't be matched
++   * to a layer get the lowest priority.
++   */
++  getLayerPriority(filePath) {
++    const layers = this.helper.nuxt.options._layers || [];
++    let priority = layers.length;
++    let longestMatch = -1;
++    for (let i = 0; i < layers.length; i++) {
++      const config = layers[i].config || {};
++      const dirs = [config.srcDir, config.rootDir, layers[i].cwd];
++      for (const dir of dirs) {
++        if (!dir) {
++          continue;
++        }
++        const prefix = dir.endsWith("/") ? dir : dir + "/";
++        if (filePath.startsWith(prefix) && dir.length > longestMatch) {
++          priority = i;
++          longestMatch = dir.length;
++        }
++      }
++    }
++    return priority;
++  }
++  /**
++   * Resolve collisions where multiple collected files define the same block
++   * bundle (or fragment name): the file from the highest-priority Nuxt layer
++   * wins, the others are shadowed. Files in the same layer are left untouched
++   * so genuine duplicates still surface as errors.
++   *
++   * @returns Whether the set of active files has changed.
++   */
++  resolveLayerOverrides() {
++    const previouslyShadowed = this.shadowed;
++    this.shadowed = /* @__PURE__ */ new Map();
++    for (const [filePath, file] of previouslyShadowed) {
++      if (!this.files.has(filePath)) {
++        this.files.set(filePath, file);
++      }
++    }
++    const byIdentifier = /* @__PURE__ */ new Map();
++    for (const file of this.files.values()) {
++      if (!file.definition || !file.identifier) {
++        continue;
++      }
++      const group = byIdentifier.get(file.identifier);
++      if (group) {
++        group.push(file);
++      } else {
++        byIdentifier.set(file.identifier, [file]);
++      }
++    }
++    for (const group of byIdentifier.values()) {
++      if (group.length < 2) {
++        continue;
++      }
++      const priorities = group.map((file) => this.getLayerPriority(file.filePath));
++      const winningPriority = Math.min(...priorities);
++      group.forEach((file, index) => {
++        if (priorities[index] > winningPriority) {
++          this.shadowed.set(file.filePath, file);
++          this.files.delete(file.filePath);
++        }
++      });
++    }
++    if (previouslyShadowed.size !== this.shadowed.size) {
++      return true;
++    }
++    for (const filePath of this.shadowed.keys()) {
++      if (!previouslyShadowed.has(filePath)) {
++        return true;
++      }
++    }
++    return false;
++  }
++  async handleWatchEvent(event, filePath) {
++    const result = await super.handleWatchEvent(event, filePath);
++    const overridesChanged = this.resolveLayerOverrides();
++    return { hasChanged: result.hasChanged || overridesChanged };
+   }
+   runHooks() {
+     return this.helper.nuxt.hooks.callHook("blokkli:alter-blocks", {
+@@ -348,7 +447,10 @@ class BlockCollector extends Collector {
+     if (!filePath.endsWith(".vue")) {
+       return false;
+     }
+-    if (!micromatch.isMatch(filePath, this.patterns)) {
++    if (!micromatch.isMatch(filePath, this.positivePatterns)) {
++      return false;
++    }
++    if (this.negativePatterns.length && micromatch.isMatch(filePath, this.negativePatterns)) {
+       return false;
+     }
+     if (isEditComponent(filePath)) {
+@@ -470,7 +572,19 @@ class IconCollector extends Collector {
+       this.helper.paths.srcDir,
+       "**/icon-blokkli-*.svg"
+     );
+-    const allFiles = [...filesModule, ...filesApp];
++    // Also scan all Nuxt layer directories for icon SVGs.
++    const layerFiles = [];
++    const layers = this.helper.nuxt.options._layers || [];
++    for (const layer of layers) {
++      if (layer.config && layer.config.srcDir && layer.config.srcDir !== this.helper.paths.srcDir) {
++        const files = await resolveFiles(
++          layer.config.srcDir,
++          "**/icon-blokkli-*.svg"
++        );
++        layerFiles.push(...files);
++      }
++    }
++    const allFiles = [...filesModule, ...filesApp, ...layerFiles];
+     await Promise.all(allFiles.map((filePath) => this.addFile(filePath)));
+   }
+   runHooks() {

package/patches/nuxt-graphql-middleware+5.4.0.patch

@@ -0,0 +1,232 @@
+diff --git a/node_modules/nuxt-graphql-middleware/dist/module.mjs b/node_modules/nuxt-graphql-middleware/dist/module.mjs
+index 8396abf..62f5068 100644
+--- a/node_modules/nuxt-graphql-middleware/dist/module.mjs
++++ b/node_modules/nuxt-graphql-middleware/dist/module.mjs
+@@ -215,12 +215,115 @@ class Collector {
+    */
+   fragments = [];
+   isInitialised = false;
++  /**
++   * The definition keys (kind:name) currently synced to the generator, per
++   * file path.
++   */
++  syncedDefinitionKeys = /* @__PURE__ */ new Map();
++  /**
++   * File paths whose contents have changed since the last generator sync.
++   */
++  dirtyFiles = /* @__PURE__ */ new Set();
+   async reset() {
+     this.files.clear();
++    this.syncedDefinitionKeys.clear();
++    this.dirtyFiles.clear();
+     this.generator.reset();
+     this.operationTimestamps.clear();
+     this.rpcItems.clear();
+   }
++  /**
++   * Determine the Nuxt layer priority of a file.
++   *
++   * Lower value = higher priority. The app/project layer is index 0, extended
++   * layers follow in the order they are defined. Documents provided via hooks
++   * get the highest priority. Files that can't be matched to a layer get the
++   * lowest priority.
++   */
++  getLayerPriority(filePath) {
++    if (filePath.startsWith("hook:")) {
++      return -1;
++    }
++    const layers = this.helper.nuxt.options._layers || [];
++    let priority = layers.length;
++    let longestMatch = -1;
++    for (let i = 0; i < layers.length; i++) {
++      const config = layers[i].config || {};
++      const dirs = [config.srcDir, config.rootDir, layers[i].cwd];
++      for (const dir of dirs) {
++        if (!dir) {
++          continue;
++        }
++        const prefix = dir.endsWith("/") ? dir : dir + "/";
++        if (filePath.startsWith(prefix) && dir.length > longestMatch) {
++          priority = i;
++          longestMatch = dir.length;
++        }
++      }
++    }
++    return priority;
++  }
++  /**
++   * Sync all collected files to the generator, resolving cross-layer
++   * definition collisions: when multiple files define a fragment or operation
++   * with the same name, the definition from the highest-priority Nuxt layer
++   * (the app/project first, then extended layers in order) wins and the
++   * shadowed definitions are excluded from the documents passed to the
++   * generator. This makes it possible to override a fragment or operation
++   * from a layer in the app or in a higher-priority layer. Definitions with
++   * the same layer priority are left untouched (existing behaviour).
++   */
++  syncGenerator() {
++    const owners = /* @__PURE__ */ new Map();
++    for (const [filePath, file] of this.files) {
++      const priority = this.getLayerPriority(filePath);
++      for (const def of file.parsed.definitions) {
++        if (def.kind !== "FragmentDefinition" && def.kind !== "OperationDefinition") {
++          continue;
++        }
++        const name = def.name?.value;
++        if (!name) {
++          continue;
++        }
++        const key = def.kind + ":" + name;
++        const owner = owners.get(key);
++        if (!owner || priority < owner.priority) {
++          owners.set(key, { priority });
++        }
++      }
++    }
++    for (const [filePath, file] of this.files) {
++      const priority = this.getLayerPriority(filePath);
++      const definitions = file.parsed.definitions.filter((def) => {
++        if (def.kind !== "FragmentDefinition" && def.kind !== "OperationDefinition") {
++          return true;
++        }
++        const name = def.name?.value;
++        if (!name) {
++          return true;
++        }
++        const owner = owners.get(def.kind + ":" + name);
++        return !owner || owner.priority >= priority;
++      });
++      const keys = definitions.map((def) => def.kind + ":" + (def.name?.value || "")).join("|");
++      const previousKeys = this.syncedDefinitionKeys.get(filePath);
++      const documentNode = definitions.length === file.parsed.definitions.length ? file.parsed : { ...file.parsed, definitions };
++      if (previousKeys === void 0) {
++        this.generator.add({ filePath, documentNode });
++        this.syncedDefinitionKeys.set(filePath, keys);
++      } else if (previousKeys !== keys || this.dirtyFiles.has(filePath)) {
++        this.generator.update({ filePath, documentNode });
++        this.syncedDefinitionKeys.set(filePath, keys);
++      }
++    }
++    for (const filePath of [...this.syncedDefinitionKeys.keys()]) {
++      if (!this.files.has(filePath)) {
++        this.generator.remove(filePath);
++        this.syncedDefinitionKeys.delete(filePath);
++      }
++    }
++    this.dirtyFiles.clear();
++  }
+   async updateSchema(schema) {
+     this.schema = schema;
+     this.generator.updateSchema(schema);
+@@ -436,10 +539,10 @@ class Collector {
+     const exists = this.hookDocuments.has(fullIdentifier);
+     this.hookDocuments.set(fullIdentifier, source);
+     if (exists && this.isInitialised) {
+-      this.generator.update({
+-        filePath: fullIdentifier,
+-        document: source
+-      });
++      const file = new CollectedFile(fullIdentifier, source, false);
++      this.files.set(fullIdentifier, file);
++      this.dirtyFiles.add(fullIdentifier);
++      this.syncGenerator();
+       await this.buildState();
+     }
+   }
+@@ -460,23 +563,16 @@ class Collector {
+         const filePath = this.helper.paths.nuxtConfig;
+         const file = new CollectedFile(filePath, nuxtConfigDocuments, false);
+         this.files.set(filePath, file);
+-        this.generator.add({
+-          filePath,
+-          documentNode: file.parsed
+-        });
+       }
+       const hookDocuments = [...this.hookDocuments.entries()];
+       hookDocuments.forEach(([identifier, source]) => {
+         const file = new CollectedFile(identifier, source, false);
+         this.files.set(identifier, file);
+-        this.generator.add({
+-          filePath: identifier,
+-          documentNode: file.parsed
+-        });
+       });
+       for (const filePath of this.hookFiles) {
+         await this.addFile(filePath);
+       }
++      this.syncGenerator();
+       await this.buildState();
+       if (!this.helper.isPrepare) {
+         logger.success("All GraphQL documents are valid.");
+@@ -495,10 +591,6 @@ class Collector {
+       return null;
+     }
+     this.files.set(filePath, file);
+-    this.generator.add({
+-      filePath,
+-      documentNode: file.parsed
+-    });
+     return file;
+   }
+   matchesPatternOrExists(filePath) {
+@@ -509,7 +601,11 @@ class Collector {
+       return false;
+     }
+     const result = await this.addFile(filePath);
+-    return !!result;
++    if (!result) {
++      return false;
++    }
++    this.syncGenerator();
++    return true;
+   }
+   async handleChange(filePath) {
+     if (!this.matchesPatternOrExists(filePath)) {
+@@ -524,10 +620,8 @@ class Collector {
+       if (!needsUpdate) {
+         return false;
+       }
+-      this.generator.update({
+-        filePath,
+-        documentNode: file.parsed
+-      });
++      this.dirtyFiles.add(filePath);
++      this.syncGenerator();
+     } catch {
+       return this.handleUnlink(filePath);
+     }
+@@ -539,7 +633,7 @@ class Collector {
+       return false;
+     }
+     this.files.delete(filePath);
+-    this.generator.remove(filePath);
++    this.syncGenerator();
+     return true;
+   }
+   handleUnlinkDir(folderPath) {
+@@ -1128,7 +1222,24 @@ class ModuleHelper {
+     );
+   }
+   matchesImportPattern(filePath) {
+-    return micromatch.isMatch(filePath, this.options.autoImportPatterns) || this.options.autoImportPatterns.includes(filePath);
++    // micromatch.isMatch with an array returns true if *any* pattern matches.
++    // A negated pattern (e.g. "!node_modules") matches every path that does
++    // not equal it, which would make every file match. Split the patterns and
++    // apply proper include/exclude semantics instead.
++    const positive = this.options.autoImportPatterns.filter(
++      (v) => !v.startsWith("!")
++    );
++    const negative = this.options.autoImportPatterns.filter((v) => v.startsWith("!")).map((v) => v.slice(1));
++    if (this.options.autoImportPatterns.includes(filePath)) {
++      return true;
++    }
++    if (!micromatch.isMatch(filePath, positive)) {
++      return false;
++    }
++    if (negative.length && micromatch.isMatch(filePath, negative)) {
++      return false;
++    }
++    return true;
+   }
+   addAlias(name, path) {
+     this.nuxt.options.alias[name] = path;