@geexcode/geex-angular 0.0.1

package/dist/chunk-63O7VUAZ.mjs

@@ -0,0 +1,65 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __decoratorStart = (base) => [, , , __create(base?.[__knownSymbol("metadata")] ?? null)];
+var __decoratorStrings = ["class", "method", "getter", "setter", "accessor", "field", "value", "get", "set"];
+var __expectFn = (fn) => fn !== void 0 && typeof fn !== "function" ? __typeError("Function expected") : fn;
+var __decoratorContext = (kind, name, done, metadata, fns) => ({ kind: __decoratorStrings[kind], name, metadata, addInitializer: (fn) => done._ ? __typeError("Already initialized") : fns.push(__expectFn(fn || null)) });
+var __decoratorMetadata = (array, target) => __defNormalProp(target, __knownSymbol("metadata"), array[3]);
+var __runInitializers = (array, flags, self, value) => {
+  for (var i = 0, fns = array[flags >> 1], n = fns && fns.length; i < n; i++) flags & 1 ? fns[i].call(self) : value = fns[i].call(self, value);
+  return value;
+};
+var __decorateElement = (array, flags, name, decorators, target, extra) => {
+  var fn, it, done, ctx, access, k = flags & 7, s = !!(flags & 8), p = !!(flags & 16);
+  var j = k > 3 ? array.length + 1 : k ? s ? 1 : 2 : 0, key = __decoratorStrings[k + 5];
+  var initializers = k > 3 && (array[j - 1] = []), extraInitializers = array[j] || (array[j] = []);
+  var desc = k && (!p && !s && (target = target.prototype), k < 5 && (k > 3 || !p) && __getOwnPropDesc(k < 4 ? target : { get [name]() {
+    return __privateGet(this, extra);
+  }, set [name](x) {
+    return __privateSet(this, extra, x);
+  } }, name));
+  k ? p && k < 4 && __name(extra, (k > 2 ? "set " : k > 1 ? "get " : "") + name) : __name(target, name);
+  for (var i = decorators.length - 1; i >= 0; i--) {
+    ctx = __decoratorContext(k, name, done = {}, array[3], extraInitializers);
+    if (k) {
+      ctx.static = s, ctx.private = p, access = ctx.access = { has: p ? (x) => __privateIn(target, x) : (x) => name in x };
+      if (k ^ 3) access.get = p ? (x) => (k ^ 1 ? __privateGet : __privateMethod)(x, target, k ^ 4 ? extra : desc.get) : (x) => x[name];
+      if (k > 2) access.set = p ? (x, y) => __privateSet(x, target, y, k ^ 4 ? extra : desc.set) : (x, y) => x[name] = y;
+    }
+    it = (0, decorators[i])(k ? k < 4 ? p ? extra : desc[key] : k > 4 ? void 0 : { get: desc.get, set: desc.set } : target, ctx), done._ = 1;
+    if (k ^ 4 || it === void 0) __expectFn(it) && (k > 4 ? initializers.unshift(it) : k ? p ? extra = it : desc[key] = it : target = it);
+    else if (typeof it !== "object" || it === null) __typeError("Object expected");
+    else __expectFn(fn = it.get) && (desc.get = fn), __expectFn(fn = it.set) && (desc.set = fn), __expectFn(fn = it.init) && initializers.unshift(fn);
+  }
+  return k || __decoratorMetadata(array, target), desc && __defProp(target, name, desc), p ? k ^ 4 ? extra : desc : target;
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateIn = (member, obj) => Object(obj) !== obj ? __typeError('Cannot use the "in" operator on this value') : member.has(obj);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+export {
+  __require,
+  __commonJS,
+  __decoratorStart,
+  __runInitializers,
+  __decorateElement
+};

package/dist/chunk-EBO3CZXG.mjs

@@ -0,0 +1,15 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __require,
+  __commonJS
+};

package/dist/esbuild/gql-redirect.plugin.d.mts

@@ -0,0 +1,37 @@
+/**
+ * ESBuild plugin to handle .gql imports and redirect them to .gql.ts files
+ *
+ * This plugin resolves .gql imports by checking if a corresponding .gql.ts file exists.
+ * If it does, it redirects the import to the .gql.ts file. Otherwise, it lets esbuild
+ * handle the .gql file normally.
+ *
+ * Now supports TypeScript path aliases for proper module resolution.
+ *
+ * @param {GqlRedirectPluginOptions} [options]
+ * @returns {Plugin}
+ */
+declare function gqlRedirectPlugin(options?: GqlRedirectPluginOptions): Plugin;
+declare namespace gqlRedirectPlugin {
+    export { gqlRedirectPlugin as default, gqlRedirectPlugin, type Plugin, type GqlRedirectPluginOptions, type PathMapping };
+}
+type Plugin = any;
+type GqlRedirectPluginOptions = {
+    /**
+     * Whether to enable verbose logging
+     */
+    verbose?: boolean | undefined;
+    /**
+     * Path to tsconfig.json file for path alias resolution
+     */
+    tsconfigPath?: string | undefined;
+    /**
+     * Whether to automatically run pnpm gqlgen when .gql.ts files are missing
+     */
+    autoGqlGen?: boolean | undefined;
+};
+type PathMapping = {
+    alias: string;
+    paths: string[];
+};
+
+export { gqlRedirectPlugin as default };

package/dist/esbuild/gql-redirect.plugin.d.ts

@@ -0,0 +1,37 @@
+/**
+ * ESBuild plugin to handle .gql imports and redirect them to .gql.ts files
+ *
+ * This plugin resolves .gql imports by checking if a corresponding .gql.ts file exists.
+ * If it does, it redirects the import to the .gql.ts file. Otherwise, it lets esbuild
+ * handle the .gql file normally.
+ *
+ * Now supports TypeScript path aliases for proper module resolution.
+ *
+ * @param {GqlRedirectPluginOptions} [options]
+ * @returns {Plugin}
+ */
+declare function gqlRedirectPlugin(options?: GqlRedirectPluginOptions): Plugin;
+declare namespace gqlRedirectPlugin {
+    export { gqlRedirectPlugin as default, gqlRedirectPlugin, type Plugin, type GqlRedirectPluginOptions, type PathMapping };
+}
+type Plugin = any;
+type GqlRedirectPluginOptions = {
+    /**
+     * Whether to enable verbose logging
+     */
+    verbose?: boolean | undefined;
+    /**
+     * Path to tsconfig.json file for path alias resolution
+     */
+    tsconfigPath?: string | undefined;
+    /**
+     * Whether to automatically run pnpm gqlgen when .gql.ts files are missing
+     */
+    autoGqlGen?: boolean | undefined;
+};
+type PathMapping = {
+    alias: string;
+    paths: string[];
+};
+
+export { gqlRedirectPlugin as default };

package/dist/esbuild/gql-redirect.plugin.js

@@ -0,0 +1,261 @@
+"use strict";
+
+// src/esbuild/gql-redirect.plugin.js
+var path = require("path");
+var fs = require("fs");
+var json5 = require("json5");
+var crypto = require("crypto");
+var { execSync } = require("child_process");
+var { glob } = require("glob");
+var yaml = require("yaml");
+var graphqlrcContent = void 0;
+function loadTsconfigPaths(tsconfigPath) {
+  try {
+    const tsconfig = json5.parse(fs.readFileSync(tsconfigPath, "utf8"));
+    const baseUrl = tsconfig.compilerOptions && tsconfig.compilerOptions.baseUrl || "./";
+    const paths = tsconfig.compilerOptions && tsconfig.compilerOptions.paths || {};
+    return Object.entries(paths).map(([alias, pathList]) => ({
+      alias: alias.replace(/\/\*$/, ""),
+      paths: (
+        /** @type {string[]} */
+        pathList.map(
+          (p) => path.resolve(path.dirname(tsconfigPath), baseUrl, p.replace(/\/\*$/, ""))
+        )
+      )
+    }));
+  } catch (error) {
+    console.warn(`[gql-redirect] Failed to load tsconfig from ${tsconfigPath}:`, error);
+    return [];
+  }
+}
+function findAngularJsonDir(startDir) {
+  try {
+    let dir = startDir;
+    while (true) {
+      if (fs.existsSync(path.join(dir, "angular.json"))) return dir;
+      const parent = path.dirname(dir);
+      if (parent === dir) return startDir;
+      dir = parent;
+    }
+  } catch {
+    return startDir;
+  }
+}
+function parseGraphqlrcDocuments(projectRoot) {
+  try {
+    const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+    if (!fs.existsSync(graphqlrcPath)) {
+      console.warn("[gql-redirect] .graphqlrc.yml not found, falling back to default patterns");
+      return [];
+    }
+    graphqlrcContent ?? (graphqlrcContent = fs.readFileSync(graphqlrcPath, "utf8"));
+    const cleanContent = graphqlrcContent.replace(/^# gql-hash:.*\n/, "");
+    const config = yaml.parse(cleanContent);
+    if (!config || !config.documents) {
+      console.warn("[gql-redirect] No documents section found in .graphqlrc.yml");
+      return [];
+    }
+    const documents = config.documents;
+    if (Array.isArray(documents)) {
+      return documents.filter((doc) => typeof doc === "string");
+    } else if (typeof documents === "string") {
+      return [documents];
+    } else {
+      console.warn("[gql-redirect] Unexpected documents format in .graphqlrc.yml");
+      return [];
+    }
+  } catch (error) {
+    console.warn(`[gql-redirect] Failed to parse .graphqlrc.yml:`, error.message);
+    return [];
+  }
+}
+function findGqlFilesByDocuments(projectRoot) {
+  try {
+    const documentPatterns = parseGraphqlrcDocuments(projectRoot);
+    const allFiles = /* @__PURE__ */ new Set();
+    for (const pattern of documentPatterns) {
+      if (pattern.startsWith("!")) {
+        continue;
+      }
+      try {
+        const matches = glob.sync(pattern, {
+          cwd: projectRoot,
+          absolute: true,
+          nodir: true
+        });
+        matches.forEach((file) => allFiles.add(file));
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to process pattern "${pattern}":`, error.message);
+      }
+    }
+    const negationPatterns = documentPatterns.filter((pattern) => pattern.startsWith("!"));
+    let filteredFiles = Array.from(allFiles);
+    for (const negPattern of negationPatterns) {
+      const pattern = negPattern.substring(1);
+      try {
+        const excludeMatches = glob.sync(pattern, {
+          cwd: projectRoot,
+          absolute: true,
+          nodir: true
+        });
+        const excludeSet = new Set(excludeMatches);
+        filteredFiles = filteredFiles.filter((file) => !excludeSet.has(file));
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to process negation pattern "${negPattern}":`, error.message);
+      }
+    }
+    return filteredFiles.sort();
+  } catch (error) {
+    console.warn(`[gql-redirect] Failed to find GQL files:`, error.message);
+    return [];
+  }
+}
+function calculateGqlHash(projectRoot) {
+  try {
+    const hash = crypto.createHash("md5");
+    const gqlFiles = findGqlFilesByDocuments(projectRoot);
+    for (const filePath of gqlFiles) {
+      try {
+        const content = fs.readFileSync(filePath, "utf8");
+        hash.update(`${path.relative(projectRoot, filePath)}:${content}`);
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to read ${filePath}:`, error.message);
+      }
+    }
+    const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+    if (fs.existsSync(graphqlrcPath)) {
+      try {
+        graphqlrcContent ?? (graphqlrcContent = fs.readFileSync(graphqlrcPath, "utf8"));
+        const cleanContent = graphqlrcContent.replace(/^# gql-hash: .*/m, "");
+        hash.update(`.graphqlrc.yml:${cleanContent}`);
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to read .graphqlrc.yml:`, error.message);
+      }
+    }
+    return hash.digest("hex");
+  } catch (error) {
+    console.warn(`[gql-redirect] Failed to calculate GQL hash:`, error.message);
+    return "";
+  }
+}
+function getPreviousGqlHash(projectRoot) {
+  try {
+    const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+    if (!fs.existsSync(graphqlrcPath)) {
+      return "";
+    }
+    graphqlrcContent ?? (graphqlrcContent = fs.readFileSync(graphqlrcPath, "utf8"));
+    const match = graphqlrcContent.match(/^# gql-hash: (.*)$/m);
+    return match ? match[1].trim() : "";
+  } catch (error) {
+    console.warn(`[gql-redirect] Failed to read previous GQL hash:`, error.message);
+    return "";
+  }
+}
+function updateGraphqlrcHash(projectRoot, newHash) {
+  try {
+    const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+    if (!fs.existsSync(graphqlrcPath)) {
+      return;
+    }
+    const currentContent = fs.readFileSync(graphqlrcPath, "utf8");
+    const newContent = currentContent.replace(/^# gql-hash: .*/m, `# gql-hash: ${newHash}`);
+    fs.writeFileSync(graphqlrcPath, newContent, "utf8");
+  } catch (error) {
+    console.warn(`[gql-redirect] Failed to update .graphqlrc.yml hash:`, error.message);
+  }
+}
+function runGqlGen(projectRoot, verbose) {
+  try {
+    const currentGqlHash = calculateGqlHash(projectRoot);
+    const previousGqlHash = getPreviousGqlHash(projectRoot);
+    if (currentGqlHash && currentGqlHash === previousGqlHash) {
+      console.log("[gql-redirect] GQL files unchanged, skipping pnpm gqlgen");
+      return true;
+    }
+    console.log(`[gql-redirect] GQL files changed (${previousGqlHash}) => (${currentGqlHash}), running pnpm gqlgen in ${projectRoot}...`);
+    try {
+      execSync("pnpm gqlgen", {
+        cwd: projectRoot,
+        stdio: verbose ? "inherit" : "pipe",
+        timeout: 3e4
+        // 30 second timeout
+      });
+    } catch (error) {
+      if (error.message.includes("NODE_TLS_REJECT_UNAUTHORIZED")) {
+      }
+    }
+    if (currentGqlHash) {
+      updateGraphqlrcHash(projectRoot, currentGqlHash);
+    }
+    if (verbose) {
+      console.log("[gql-redirect] Successfully executed pnpm gqlgen and updated hash");
+    }
+    return true;
+  } catch (error) {
+    console.error(`[gql-redirect] Failed to execute pnpm gqlgen:`, error.message);
+    return false;
+  }
+}
+function resolvePathAlias(modulePath, pathMappings, resolveDir) {
+  const possiblePaths = [];
+  for (const mapping of pathMappings) {
+    if (modulePath.startsWith(mapping.alias)) {
+      const remainingPath = modulePath.slice(mapping.alias.length);
+      const cleanRemainingPath = remainingPath.startsWith("/") ? remainingPath.slice(1) : remainingPath;
+      for (const basePath of mapping.paths) {
+        const resolvedPath = cleanRemainingPath ? path.join(basePath, cleanRemainingPath) : basePath;
+        possiblePaths.push(resolvedPath);
+      }
+    }
+  }
+  if (possiblePaths.length === 0) {
+    possiblePaths.push(path.resolve(resolveDir, modulePath));
+  }
+  return possiblePaths;
+}
+function gqlRedirectPlugin(options = {}) {
+  const { verbose = false, tsconfigPath = "./tsconfig.json", autoGqlGen = true } = options;
+  return {
+    name: "gql-redirect",
+    setup(build) {
+      const angularJsonDir = findAngularJsonDir(process.cwd());
+      const pathMappings = loadTsconfigPaths(tsconfigPath);
+      if (verbose && pathMappings.length > 0) {
+        console.log(`[gql-redirect] Loaded ${pathMappings.length} path mappings from ${tsconfigPath}`);
+      }
+      if (autoGqlGen) {
+        runGqlGen(angularJsonDir, verbose);
+      }
+      build.onResolve({ filter: /\.gql$/ }, (args) => {
+        try {
+          const possiblePaths = resolvePathAlias(args.path, pathMappings, args.resolveDir);
+          for (const resolvedPath of possiblePaths) {
+            const gqlTsPath = resolvedPath + ".ts";
+            if (fs.existsSync(gqlTsPath)) {
+              if (verbose) {
+                const displayPath = path.relative(angularJsonDir, gqlTsPath) || ".";
+                console.log(`[gql-redirect] Redirecting "${args.path}" to "${displayPath}"`);
+              }
+              return { path: gqlTsPath };
+            }
+          }
+          if (verbose) {
+            console.warn(`[gql-redirect] No .gql.ts found for ${args.path} in any of the resolved paths: ${possiblePaths.join(", ")}`);
+          } else {
+            console.warn(`[gql-redirect] No .gql.ts found for ${args.path}, please run pnpm gqlgen to ensure it.`);
+          }
+          return null;
+        } catch (error) {
+          if (verbose) {
+            console.error(`[gql-redirect] Error processing ${args.path}:`, error);
+          }
+          return null;
+        }
+      });
+    }
+  };
+}
+module.exports = gqlRedirectPlugin;
+module.exports.default = gqlRedirectPlugin;
+module.exports.gqlRedirectPlugin = gqlRedirectPlugin;

package/dist/esbuild/gql-redirect.plugin.mjs

@@ -0,0 +1,269 @@
+import {
+  __commonJS,
+  __require
+} from "../chunk-EBO3CZXG.mjs";
+
+// src/esbuild/gql-redirect.plugin.js
+var require_gql_redirect_plugin = __commonJS({
+  "src/esbuild/gql-redirect.plugin.js"(exports, module) {
+    var path = __require("path");
+    var fs = __require("fs");
+    var json5 = __require("json5");
+    var crypto = __require("crypto");
+    var { execSync } = __require("child_process");
+    var { glob } = __require("glob");
+    var yaml = __require("yaml");
+    var graphqlrcContent = void 0;
+    function loadTsconfigPaths(tsconfigPath) {
+      try {
+        const tsconfig = json5.parse(fs.readFileSync(tsconfigPath, "utf8"));
+        const baseUrl = tsconfig.compilerOptions && tsconfig.compilerOptions.baseUrl || "./";
+        const paths = tsconfig.compilerOptions && tsconfig.compilerOptions.paths || {};
+        return Object.entries(paths).map(([alias, pathList]) => ({
+          alias: alias.replace(/\/\*$/, ""),
+          paths: (
+            /** @type {string[]} */
+            pathList.map(
+              (p) => path.resolve(path.dirname(tsconfigPath), baseUrl, p.replace(/\/\*$/, ""))
+            )
+          )
+        }));
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to load tsconfig from ${tsconfigPath}:`, error);
+        return [];
+      }
+    }
+    function findAngularJsonDir(startDir) {
+      try {
+        let dir = startDir;
+        while (true) {
+          if (fs.existsSync(path.join(dir, "angular.json"))) return dir;
+          const parent = path.dirname(dir);
+          if (parent === dir) return startDir;
+          dir = parent;
+        }
+      } catch {
+        return startDir;
+      }
+    }
+    function parseGraphqlrcDocuments(projectRoot) {
+      try {
+        const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+        if (!fs.existsSync(graphqlrcPath)) {
+          console.warn("[gql-redirect] .graphqlrc.yml not found, falling back to default patterns");
+          return [];
+        }
+        graphqlrcContent ?? (graphqlrcContent = fs.readFileSync(graphqlrcPath, "utf8"));
+        const cleanContent = graphqlrcContent.replace(/^# gql-hash:.*\n/, "");
+        const config = yaml.parse(cleanContent);
+        if (!config || !config.documents) {
+          console.warn("[gql-redirect] No documents section found in .graphqlrc.yml");
+          return [];
+        }
+        const documents = config.documents;
+        if (Array.isArray(documents)) {
+          return documents.filter((doc) => typeof doc === "string");
+        } else if (typeof documents === "string") {
+          return [documents];
+        } else {
+          console.warn("[gql-redirect] Unexpected documents format in .graphqlrc.yml");
+          return [];
+        }
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to parse .graphqlrc.yml:`, error.message);
+        return [];
+      }
+    }
+    function findGqlFilesByDocuments(projectRoot) {
+      try {
+        const documentPatterns = parseGraphqlrcDocuments(projectRoot);
+        const allFiles = /* @__PURE__ */ new Set();
+        for (const pattern of documentPatterns) {
+          if (pattern.startsWith("!")) {
+            continue;
+          }
+          try {
+            const matches = glob.sync(pattern, {
+              cwd: projectRoot,
+              absolute: true,
+              nodir: true
+            });
+            matches.forEach((file) => allFiles.add(file));
+          } catch (error) {
+            console.warn(`[gql-redirect] Failed to process pattern "${pattern}":`, error.message);
+          }
+        }
+        const negationPatterns = documentPatterns.filter((pattern) => pattern.startsWith("!"));
+        let filteredFiles = Array.from(allFiles);
+        for (const negPattern of negationPatterns) {
+          const pattern = negPattern.substring(1);
+          try {
+            const excludeMatches = glob.sync(pattern, {
+              cwd: projectRoot,
+              absolute: true,
+              nodir: true
+            });
+            const excludeSet = new Set(excludeMatches);
+            filteredFiles = filteredFiles.filter((file) => !excludeSet.has(file));
+          } catch (error) {
+            console.warn(`[gql-redirect] Failed to process negation pattern "${negPattern}":`, error.message);
+          }
+        }
+        return filteredFiles.sort();
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to find GQL files:`, error.message);
+        return [];
+      }
+    }
+    function calculateGqlHash(projectRoot) {
+      try {
+        const hash = crypto.createHash("md5");
+        const gqlFiles = findGqlFilesByDocuments(projectRoot);
+        for (const filePath of gqlFiles) {
+          try {
+            const content = fs.readFileSync(filePath, "utf8");
+            hash.update(`${path.relative(projectRoot, filePath)}:${content}`);
+          } catch (error) {
+            console.warn(`[gql-redirect] Failed to read ${filePath}:`, error.message);
+          }
+        }
+        const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+        if (fs.existsSync(graphqlrcPath)) {
+          try {
+            graphqlrcContent ?? (graphqlrcContent = fs.readFileSync(graphqlrcPath, "utf8"));
+            const cleanContent = graphqlrcContent.replace(/^# gql-hash: .*/m, "");
+            hash.update(`.graphqlrc.yml:${cleanContent}`);
+          } catch (error) {
+            console.warn(`[gql-redirect] Failed to read .graphqlrc.yml:`, error.message);
+          }
+        }
+        return hash.digest("hex");
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to calculate GQL hash:`, error.message);
+        return "";
+      }
+    }
+    function getPreviousGqlHash(projectRoot) {
+      try {
+        const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+        if (!fs.existsSync(graphqlrcPath)) {
+          return "";
+        }
+        graphqlrcContent ?? (graphqlrcContent = fs.readFileSync(graphqlrcPath, "utf8"));
+        const match = graphqlrcContent.match(/^# gql-hash: (.*)$/m);
+        return match ? match[1].trim() : "";
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to read previous GQL hash:`, error.message);
+        return "";
+      }
+    }
+    function updateGraphqlrcHash(projectRoot, newHash) {
+      try {
+        const graphqlrcPath = path.join(projectRoot, ".graphqlrc.yml");
+        if (!fs.existsSync(graphqlrcPath)) {
+          return;
+        }
+        const currentContent = fs.readFileSync(graphqlrcPath, "utf8");
+        const newContent = currentContent.replace(/^# gql-hash: .*/m, `# gql-hash: ${newHash}`);
+        fs.writeFileSync(graphqlrcPath, newContent, "utf8");
+      } catch (error) {
+        console.warn(`[gql-redirect] Failed to update .graphqlrc.yml hash:`, error.message);
+      }
+    }
+    function runGqlGen(projectRoot, verbose) {
+      try {
+        const currentGqlHash = calculateGqlHash(projectRoot);
+        const previousGqlHash = getPreviousGqlHash(projectRoot);
+        if (currentGqlHash && currentGqlHash === previousGqlHash) {
+          console.log("[gql-redirect] GQL files unchanged, skipping pnpm gqlgen");
+          return true;
+        }
+        console.log(`[gql-redirect] GQL files changed (${previousGqlHash}) => (${currentGqlHash}), running pnpm gqlgen in ${projectRoot}...`);
+        try {
+          execSync("pnpm gqlgen", {
+            cwd: projectRoot,
+            stdio: verbose ? "inherit" : "pipe",
+            timeout: 3e4
+            // 30 second timeout
+          });
+        } catch (error) {
+          if (error.message.includes("NODE_TLS_REJECT_UNAUTHORIZED")) {
+          }
+        }
+        if (currentGqlHash) {
+          updateGraphqlrcHash(projectRoot, currentGqlHash);
+        }
+        if (verbose) {
+          console.log("[gql-redirect] Successfully executed pnpm gqlgen and updated hash");
+        }
+        return true;
+      } catch (error) {
+        console.error(`[gql-redirect] Failed to execute pnpm gqlgen:`, error.message);
+        return false;
+      }
+    }
+    function resolvePathAlias(modulePath, pathMappings, resolveDir) {
+      const possiblePaths = [];
+      for (const mapping of pathMappings) {
+        if (modulePath.startsWith(mapping.alias)) {
+          const remainingPath = modulePath.slice(mapping.alias.length);
+          const cleanRemainingPath = remainingPath.startsWith("/") ? remainingPath.slice(1) : remainingPath;
+          for (const basePath of mapping.paths) {
+            const resolvedPath = cleanRemainingPath ? path.join(basePath, cleanRemainingPath) : basePath;
+            possiblePaths.push(resolvedPath);
+          }
+        }
+      }
+      if (possiblePaths.length === 0) {
+        possiblePaths.push(path.resolve(resolveDir, modulePath));
+      }
+      return possiblePaths;
+    }
+    function gqlRedirectPlugin(options = {}) {
+      const { verbose = false, tsconfigPath = "./tsconfig.json", autoGqlGen = true } = options;
+      return {
+        name: "gql-redirect",
+        setup(build) {
+          const angularJsonDir = findAngularJsonDir(process.cwd());
+          const pathMappings = loadTsconfigPaths(tsconfigPath);
+          if (verbose && pathMappings.length > 0) {
+            console.log(`[gql-redirect] Loaded ${pathMappings.length} path mappings from ${tsconfigPath}`);
+          }
+          if (autoGqlGen) {
+            runGqlGen(angularJsonDir, verbose);
+          }
+          build.onResolve({ filter: /\.gql$/ }, (args) => {
+            try {
+              const possiblePaths = resolvePathAlias(args.path, pathMappings, args.resolveDir);
+              for (const resolvedPath of possiblePaths) {
+                const gqlTsPath = resolvedPath + ".ts";
+                if (fs.existsSync(gqlTsPath)) {
+                  if (verbose) {
+                    const displayPath = path.relative(angularJsonDir, gqlTsPath) || ".";
+                    console.log(`[gql-redirect] Redirecting "${args.path}" to "${displayPath}"`);
+                  }
+                  return { path: gqlTsPath };
+                }
+              }
+              if (verbose) {
+                console.warn(`[gql-redirect] No .gql.ts found for ${args.path} in any of the resolved paths: ${possiblePaths.join(", ")}`);
+              } else {
+                console.warn(`[gql-redirect] No .gql.ts found for ${args.path}, please run pnpm gqlgen to ensure it.`);
+              }
+              return null;
+            } catch (error) {
+              if (verbose) {
+                console.error(`[gql-redirect] Error processing ${args.path}:`, error);
+              }
+              return null;
+            }
+          });
+        }
+      };
+    }
+    module.exports = gqlRedirectPlugin;
+    module.exports.default = gqlRedirectPlugin;
+    module.exports.gqlRedirectPlugin = gqlRedirectPlugin;
+  }
+});
+export default require_gql_redirect_plugin();

package/dist/index.d.mts

@@ -0,0 +1,97 @@
+import { WritableSignal, Injector, Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+
+interface Tenant {
+    code: string;
+    name: string;
+}
+interface Org {
+    code: string;
+    name: string;
+    [key: string]: any;
+}
+interface UserOrgMembership {
+    code: string;
+}
+interface User {
+    id: string;
+    orgs: UserOrgMembership[];
+    [key: string]: any;
+}
+interface SettingItem {
+    name: string;
+    value?: any;
+}
+interface TenantModule extends GeexModule {
+    /** Current tenant reactive state */
+    current: WritableSignal<Tenant | null>;
+    /**
+     * Load tenant information by code.
+     */
+    loadTenantData(code: string): Promise<Tenant>;
+    /**
+     * Switch current tenant.
+     */
+    switchTenant(targetTenantCode: string): void;
+}
+interface AuthModule extends GeexModule {
+    /** Current authenticated user */
+    user: WritableSignal<User | null>;
+    /**
+     * Load current user information. Returns undefined when unauthenticated.
+     */
+    loadUserData(): Promise<User | undefined>;
+}
+interface IdentityModule extends GeexModule {
+    /** All organizations */
+    orgs: WritableSignal<Org[]>;
+    /** Organizations owned by current user */
+    userOwnedOrgs: WritableSignal<Org[]>;
+    /**
+     * Initialize identity-related reactive state and listeners.
+     */
+    init(): void;
+}
+interface MessagingModule extends GeexModule {
+    /**
+     * Subscribe to server broadcast events.
+     */
+    onPublicNotify(): void;
+}
+interface SettingsModule extends GeexModule {
+    settings: WritableSignal<SettingItem[]>;
+    /**
+     * Initialize application settings.
+     */
+    init(): Promise<void>;
+}
+interface UiModule extends GeexModule {
+    /** Whether the app is currently in fullscreen mode */
+    fullScreen: WritableSignal<boolean>;
+    /** Responsive helper stream notifying if device is mobile-like */
+    isMobile$: Observable<boolean>;
+    /** Currently active routed component (framework dependent) */
+    activeRoutedComponent?: any;
+}
+type GeexModules<TExtensionModules extends Record<string, GeexModule> = {}> = {
+    tenant: TenantModule;
+    auth: AuthModule;
+    identity: IdentityModule;
+    messaging: MessagingModule;
+    settings: SettingsModule;
+    ui: UiModule;
+} & TExtensionModules;
+type GeexModule<TExtension = any> = {} & TExtension;
+
+type GeexOverrides<TExtensionModules extends Record<string, GeexModule> = {}> = Partial<GeexModules<TExtensionModules>>;
+declare let geex: GeexModules;
+/**
+ * Initialize geex singleton with concrete dependencies
+ * @param deps   Required runtime services
+ * @param overrides  Custom module overrides – properties will be merged into generated modules
+ */
+declare function configGeex<TExtensionModules extends Record<string, GeexModule> = {}>(injector: Injector, overrides?: GeexOverrides<TExtensionModules>): void;
+
+declare function provideGeex(injector: any, overrides?: GeexOverrides): Provider[];
+
+export { type GeexOverrides, configGeex, geex, provideGeex };

package/dist/index.d.ts

@@ -0,0 +1,97 @@
+import { WritableSignal, Injector, Provider } from '@angular/core';
+import { Observable } from 'rxjs';
+
+interface Tenant {
+    code: string;
+    name: string;
+}
+interface Org {
+    code: string;
+    name: string;
+    [key: string]: any;
+}
+interface UserOrgMembership {
+    code: string;
+}
+interface User {
+    id: string;
+    orgs: UserOrgMembership[];
+    [key: string]: any;
+}
+interface SettingItem {
+    name: string;
+    value?: any;
+}
+interface TenantModule extends GeexModule {
+    /** Current tenant reactive state */
+    current: WritableSignal<Tenant | null>;
+    /**
+     * Load tenant information by code.
+     */
+    loadTenantData(code: string): Promise<Tenant>;
+    /**
+     * Switch current tenant.
+     */
+    switchTenant(targetTenantCode: string): void;
+}
+interface AuthModule extends GeexModule {
+    /** Current authenticated user */
+    user: WritableSignal<User | null>;
+    /**
+     * Load current user information. Returns undefined when unauthenticated.
+     */
+    loadUserData(): Promise<User | undefined>;
+}
+interface IdentityModule extends GeexModule {
+    /** All organizations */
+    orgs: WritableSignal<Org[]>;
+    /** Organizations owned by current user */
+    userOwnedOrgs: WritableSignal<Org[]>;
+    /**
+     * Initialize identity-related reactive state and listeners.
+     */
+    init(): void;
+}
+interface MessagingModule extends GeexModule {
+    /**
+     * Subscribe to server broadcast events.
+     */
+    onPublicNotify(): void;
+}
+interface SettingsModule extends GeexModule {
+    settings: WritableSignal<SettingItem[]>;
+    /**
+     * Initialize application settings.
+     */
+    init(): Promise<void>;
+}
+interface UiModule extends GeexModule {
+    /** Whether the app is currently in fullscreen mode */
+    fullScreen: WritableSignal<boolean>;
+    /** Responsive helper stream notifying if device is mobile-like */
+    isMobile$: Observable<boolean>;
+    /** Currently active routed component (framework dependent) */
+    activeRoutedComponent?: any;
+}
+type GeexModules<TExtensionModules extends Record<string, GeexModule> = {}> = {
+    tenant: TenantModule;
+    auth: AuthModule;
+    identity: IdentityModule;
+    messaging: MessagingModule;
+    settings: SettingsModule;
+    ui: UiModule;
+} & TExtensionModules;
+type GeexModule<TExtension = any> = {} & TExtension;
+
+type GeexOverrides<TExtensionModules extends Record<string, GeexModule> = {}> = Partial<GeexModules<TExtensionModules>>;
+declare let geex: GeexModules;
+/**
+ * Initialize geex singleton with concrete dependencies
+ * @param deps   Required runtime services
+ * @param overrides  Custom module overrides – properties will be merged into generated modules
+ */
+declare function configGeex<TExtensionModules extends Record<string, GeexModule> = {}>(injector: Injector, overrides?: GeexOverrides<TExtensionModules>): void;
+
+declare function provideGeex(injector: any, overrides?: GeexOverrides): Provider[];
+
+export { type GeexOverrides, configGeex, geex, provideGeex };

package/dist/index.js

@@ -0,0 +1,206 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  configGeex: () => configGeex,
+  geex: () => geex,
+  provideGeex: () => provideGeex
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/geex.ts
+var import_core2 = require("@angular/core");
+
+// src/modules.ts
+var import_apollo_angular = require("apollo-angular");
+var import_core = require("@angular/core");
+var import_angular_oauth2_oidc = require("angular-oauth2-oidc");
+var import_util = require("@delon/util");
+var import_graphql_tag = __toESM(require("graphql-tag"));
+var import_rxjs = require("rxjs");
+var import_operators = require("rxjs/operators");
+var GQL_CHECK_TENANT = import_graphql_tag.default`mutation checkTenant($code: String!) { checkTenant(code: $code) { code name } }`;
+var GQL_FEDERATE_AUTH = import_graphql_tag.default`mutation federateAuthenticate($code: String!, $loginProvider: LoginProviderEnum!) { federateAuthenticate(code: $code, loginProvider: $loginProvider) { id orgs { code } } }`;
+var GQL_ON_PUBLIC_NOTIFY = import_graphql_tag.default`subscription onPublicNotify { onPublicNotify { __typename ... on DataChangeClientNotify { dataChangeType } } }`;
+var GQL_ORGS_CACHE = import_graphql_tag.default`query orgsCache { orgs { items { code name } } }`;
+var GQL_INIT_SETTINGS = import_graphql_tag.default`query initSettings { initSettings { name value } }`;
+function createTenantModule(injector) {
+  const current = (0, import_core.signal)(null);
+  return {
+    current,
+    async loadTenantData(code) {
+      const res = await (0, import_rxjs.firstValueFrom)(
+        injector.get(import_apollo_angular.Apollo).mutate({ mutation: GQL_CHECK_TENANT, variables: { code } })
+      );
+      return res.data.checkTenant;
+    },
+    switchTenant(targetTenantCode) {
+      const domainParts = location.hostname.split(".");
+      if (domainParts.length > 2) {
+        domainParts.shift();
+      }
+      const rootDomain = domainParts.join(".");
+      injector.get(import_util.CookieService).put("__tenant", targetTenantCode, {
+        secure: false,
+        SameSite: "lax",
+        HttpOnly: false,
+        domain: rootDomain
+      });
+    }
+  };
+}
+function createAuthModule(injector) {
+  const user = (0, import_core.signal)(null);
+  return {
+    user,
+    async loadUserData() {
+      const oAuthService = injector.get(import_angular_oauth2_oidc.OAuthService);
+      try {
+        await oAuthService.loadUserProfile();
+        const profile = oAuthService.getIdentityClaims();
+        if (profile && oAuthService.hasValidAccessToken()) {
+          const result = await (0, import_rxjs.firstValueFrom)(injector.get(import_apollo_angular.Apollo).mutate({
+            mutation: GQL_FEDERATE_AUTH,
+            variables: {
+              code: oAuthService.getAccessToken(),
+              loginProvider: profile.login_provider
+            }
+          }).pipe((0, import_rxjs.map)((res) => res?.data?.federateAuthenticate)));
+          return result;
+        }
+      } catch (err) {
+        console.error(err);
+        oAuthService.logOut();
+      }
+      return void 0;
+    }
+  };
+}
+function createIdentityModule(injector) {
+  const orgsSignal = (0, import_core.signal)([]);
+  const userOwnedOrgsSignal = (0, import_core.signal)([]);
+  return {
+    orgs: orgsSignal,
+    userOwnedOrgs: userOwnedOrgsSignal,
+    init() {
+      const orgs$ = injector.get(import_apollo_angular.Apollo).watchQuery({ query: GQL_ORGS_CACHE }).valueChanges.pipe((0, import_rxjs.map)((res) => (0, import_util.deepCopy)(res.data.orgs.items)));
+      orgs$.subscribe((orgs) => {
+        (0, import_core.runInInjectionContext)(injector, () => {
+          orgsSignal.set(orgs);
+          const userData = geex.auth.user();
+          let allOwned = [];
+          if (orgs?.length && userData) {
+            if (userData.id === "000000000000000000000001") {
+              allOwned = (0, import_util.deepCopy)(orgs);
+            } else {
+              const ownedCodes = userData.orgs.map((x) => x.code);
+              allOwned = orgs.filter((o) => ownedCodes.some((code) => o.code.startsWith(code)));
+            }
+          }
+          userOwnedOrgsSignal.set(allOwned);
+        });
+      });
+    }
+  };
+}
+function createMessagingModule(injector) {
+  return {
+    onPublicNotify() {
+      const subClient = injector.get(import_apollo_angular.Apollo).use("subscription");
+      subClient.subscribe({ query: GQL_ON_PUBLIC_NOTIFY }).pipe((0, import_rxjs.map)((res) => res?.data?.onPublicNotify)).subscribe((notify) => {
+        console.log("Public notify", notify);
+      });
+    }
+  };
+}
+function createSettingsModule(injector) {
+  const settingsSignal = (0, import_core.signal)([]);
+  return {
+    settings: settingsSignal,
+    async init() {
+      const res = await (0, import_rxjs.firstValueFrom)(
+        injector.get(import_apollo_angular.Apollo).query({ query: GQL_INIT_SETTINGS })
+      );
+      const settings = res.data.initSettings;
+      settingsSignal.set(settings);
+    }
+  };
+}
+function createUiModule(injector) {
+  const fullScreenSignal = (0, import_core.signal)(false);
+  const isMobile$ = (0, import_rxjs.fromEvent)(window, "resize").pipe(
+    (0, import_operators.debounceTime)(200),
+    (0, import_operators.switchMap)(async () => window.innerHeight / window.innerWidth >= 1.5)
+  );
+  return {
+    fullScreen: fullScreenSignal,
+    isMobile$,
+    activeRoutedComponent: void 0
+  };
+}
+
+// src/geex.ts
+var geex;
+function configGeex(injector, overrides) {
+  (0, import_core2.runInInjectionContext)(injector, () => {
+    const modules = {
+      tenant: createTenantModule(injector),
+      auth: createAuthModule(injector),
+      identity: createIdentityModule(injector),
+      messaging: createMessagingModule(injector),
+      settings: createSettingsModule(injector),
+      ui: createUiModule(injector)
+    };
+    if (overrides) {
+      Object.assign(modules, overrides);
+    }
+    geex = modules;
+  });
+}
+
+// src/tokens.ts
+var import_core3 = require("@angular/core");
+var GEEX_CONFIG = new import_core3.InjectionToken("GEEX_CONFIG");
+
+// src/provide-geex.ts
+function provideGeex(injector, overrides) {
+  configGeex(injector, overrides);
+  return [
+    { provide: GEEX_CONFIG, useValue: { injector, overrides } },
+    { provide: geex, useExisting: geex }
+  ];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configGeex,
+  geex,
+  provideGeex
+});

package/dist/index.mjs

@@ -0,0 +1,169 @@
+import "./chunk-EBO3CZXG.mjs";
+
+// src/geex.ts
+import { runInInjectionContext as runInInjectionContext2 } from "@angular/core";
+
+// src/modules.ts
+import { Apollo } from "apollo-angular";
+import { runInInjectionContext, signal } from "@angular/core";
+import { OAuthService } from "angular-oauth2-oidc";
+import { CookieService, deepCopy } from "@delon/util";
+import gql from "graphql-tag";
+import { firstValueFrom, map, fromEvent } from "rxjs";
+import { debounceTime, switchMap } from "rxjs/operators";
+var GQL_CHECK_TENANT = gql`mutation checkTenant($code: String!) { checkTenant(code: $code) { code name } }`;
+var GQL_FEDERATE_AUTH = gql`mutation federateAuthenticate($code: String!, $loginProvider: LoginProviderEnum!) { federateAuthenticate(code: $code, loginProvider: $loginProvider) { id orgs { code } } }`;
+var GQL_ON_PUBLIC_NOTIFY = gql`subscription onPublicNotify { onPublicNotify { __typename ... on DataChangeClientNotify { dataChangeType } } }`;
+var GQL_ORGS_CACHE = gql`query orgsCache { orgs { items { code name } } }`;
+var GQL_INIT_SETTINGS = gql`query initSettings { initSettings { name value } }`;
+function createTenantModule(injector) {
+  const current = signal(null);
+  return {
+    current,
+    async loadTenantData(code) {
+      const res = await firstValueFrom(
+        injector.get(Apollo).mutate({ mutation: GQL_CHECK_TENANT, variables: { code } })
+      );
+      return res.data.checkTenant;
+    },
+    switchTenant(targetTenantCode) {
+      const domainParts = location.hostname.split(".");
+      if (domainParts.length > 2) {
+        domainParts.shift();
+      }
+      const rootDomain = domainParts.join(".");
+      injector.get(CookieService).put("__tenant", targetTenantCode, {
+        secure: false,
+        SameSite: "lax",
+        HttpOnly: false,
+        domain: rootDomain
+      });
+    }
+  };
+}
+function createAuthModule(injector) {
+  const user = signal(null);
+  return {
+    user,
+    async loadUserData() {
+      const oAuthService = injector.get(OAuthService);
+      try {
+        await oAuthService.loadUserProfile();
+        const profile = oAuthService.getIdentityClaims();
+        if (profile && oAuthService.hasValidAccessToken()) {
+          const result = await firstValueFrom(injector.get(Apollo).mutate({
+            mutation: GQL_FEDERATE_AUTH,
+            variables: {
+              code: oAuthService.getAccessToken(),
+              loginProvider: profile.login_provider
+            }
+          }).pipe(map((res) => res?.data?.federateAuthenticate)));
+          return result;
+        }
+      } catch (err) {
+        console.error(err);
+        oAuthService.logOut();
+      }
+      return void 0;
+    }
+  };
+}
+function createIdentityModule(injector) {
+  const orgsSignal = signal([]);
+  const userOwnedOrgsSignal = signal([]);
+  return {
+    orgs: orgsSignal,
+    userOwnedOrgs: userOwnedOrgsSignal,
+    init() {
+      const orgs$ = injector.get(Apollo).watchQuery({ query: GQL_ORGS_CACHE }).valueChanges.pipe(map((res) => deepCopy(res.data.orgs.items)));
+      orgs$.subscribe((orgs) => {
+        runInInjectionContext(injector, () => {
+          orgsSignal.set(orgs);
+          const userData = geex.auth.user();
+          let allOwned = [];
+          if (orgs?.length && userData) {
+            if (userData.id === "000000000000000000000001") {
+              allOwned = deepCopy(orgs);
+            } else {
+              const ownedCodes = userData.orgs.map((x) => x.code);
+              allOwned = orgs.filter((o) => ownedCodes.some((code) => o.code.startsWith(code)));
+            }
+          }
+          userOwnedOrgsSignal.set(allOwned);
+        });
+      });
+    }
+  };
+}
+function createMessagingModule(injector) {
+  return {
+    onPublicNotify() {
+      const subClient = injector.get(Apollo).use("subscription");
+      subClient.subscribe({ query: GQL_ON_PUBLIC_NOTIFY }).pipe(map((res) => res?.data?.onPublicNotify)).subscribe((notify) => {
+        console.log("Public notify", notify);
+      });
+    }
+  };
+}
+function createSettingsModule(injector) {
+  const settingsSignal = signal([]);
+  return {
+    settings: settingsSignal,
+    async init() {
+      const res = await firstValueFrom(
+        injector.get(Apollo).query({ query: GQL_INIT_SETTINGS })
+      );
+      const settings = res.data.initSettings;
+      settingsSignal.set(settings);
+    }
+  };
+}
+function createUiModule(injector) {
+  const fullScreenSignal = signal(false);
+  const isMobile$ = fromEvent(window, "resize").pipe(
+    debounceTime(200),
+    switchMap(async () => window.innerHeight / window.innerWidth >= 1.5)
+  );
+  return {
+    fullScreen: fullScreenSignal,
+    isMobile$,
+    activeRoutedComponent: void 0
+  };
+}
+
+// src/geex.ts
+var geex;
+function configGeex(injector, overrides) {
+  runInInjectionContext2(injector, () => {
+    const modules = {
+      tenant: createTenantModule(injector),
+      auth: createAuthModule(injector),
+      identity: createIdentityModule(injector),
+      messaging: createMessagingModule(injector),
+      settings: createSettingsModule(injector),
+      ui: createUiModule(injector)
+    };
+    if (overrides) {
+      Object.assign(modules, overrides);
+    }
+    geex = modules;
+  });
+}
+
+// src/tokens.ts
+import { InjectionToken } from "@angular/core";
+var GEEX_CONFIG = new InjectionToken("GEEX_CONFIG");
+
+// src/provide-geex.ts
+function provideGeex(injector, overrides) {
+  configGeex(injector, overrides);
+  return [
+    { provide: GEEX_CONFIG, useValue: { injector, overrides } },
+    { provide: geex, useExisting: geex }
+  ];
+}
+export {
+  configGeex,
+  geex,
+  provideGeex
+};

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@geexcode/geex-angular",
+  "version": "0.0.1",
+  "description": "Angular adapter for Geex core.",
+  "module": "dist/index.js",
+  "main": "dist/index.cjs",
+  "types": "dist/index.d.ts",
+  "peerDependencies": {
+    "@angular/core": "^20.0.0",
+    "@angular/router": "^20.0.0",
+    "@apollo/client": "^3.9.0",
+    "@delon/util": "^15.0.0",
+    "angular-oauth2-oidc": "^15.0.0",
+    "apollo-angular": "11.0.0",
+    "graphql": "^16.8.0",
+    "rxjs": "^7.8.0",
+    "json5": "^2.2.3",
+    "yaml": "^2.8.1",
+    "glob": "^11.0.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "clean": "rimraf dist",
+    "build": "tsup src/index.ts src/esbuild/gql-redirect.plugin.js --dts --format esm,cjs --out-dir dist",
+    "prepublishOnly": "npm run build",
+    "publish:public": "npm publish --access public",
+    "release": "standard-version"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.3",
+    "tsup": "^8.0.0",
+    "rimraf": "^5.0.5",
+    "standard-version": "^9.5.0"
+  },
+  "dependencies": {
+    "graphql-tag": "^2.12.6"
+  }
+}