silgi 0.7.0 → 0.7.1

package/dist/cli/core/app.mjs

@@ -0,0 +1,89 @@
+import { mkdirSync, writeFileSync, promises } from 'node:fs';
+import { resolve, dirname } from 'pathe';
+import { normalizeTemplate, useLogger, relativeWithDot } from 'silgi/kit';
+import * as templates from './templates.mjs';
+import { pluginsDeclaration } from './templates.mjs';
+
+const postTemplates = [
+  pluginsDeclaration.filename
+];
+const logger = useLogger("silgi");
+async function generateApp(app, options = {}) {
+  app.templates = Object.values(templates).concat(app.options.build.templates);
+  await app.callHook("app:templates", app);
+  app.templates = app.templates.map((tmpl) => normalizeTemplate(tmpl, app.options.silgi.vfsDir));
+  const filteredTemplates = {
+    pre: [],
+    post: []
+  };
+  for (const template of app.templates) {
+    if (options.filter && !options.filter(template)) {
+      continue;
+    }
+    const key = template.filename && postTemplates.includes(template.filename) ? "post" : "pre";
+    filteredTemplates[key].push(template);
+  }
+  const templateContext = { app };
+  const writes = [];
+  const indexImports = [];
+  const dirs = /* @__PURE__ */ new Set();
+  const changedTemplates = [];
+  async function processTemplate(template) {
+    const fullPath = template.dst || resolve(app.options.silgi.vfsDir, template.filename);
+    const start = performance.now();
+    const contents = await compileTemplate(template, templateContext).catch((e) => {
+      logger.error(`Could not compile template \`${template.filename}\`.`);
+      logger.error(e);
+      throw e;
+    });
+    template.modified = true;
+    if (template.modified) {
+      changedTemplates.push(template);
+    }
+    const perf = performance.now() - start;
+    const setupTime = Math.round(perf * 100) / 100;
+    if (app.options.debug || setupTime > 500) {
+      logger.info(`Compiled \`${template.filename}\` in ${setupTime}ms`);
+    }
+    if (template.modified && template.write) {
+      dirs.add(dirname(fullPath));
+      if (!fullPath.endsWith(".d.ts")) {
+        indexImports.push(relativeWithDot(app.options.silgi.serverDir, fullPath));
+      }
+      writes.push(() => writeFileSync(fullPath, contents, "utf8"));
+    }
+  }
+  await Promise.allSettled(filteredTemplates.pre.map(processTemplate));
+  await Promise.allSettled(filteredTemplates.post.map(processTemplate));
+  for (const dir of dirs) {
+    mkdirSync(dir, { recursive: true });
+  }
+  for (const write of writes) {
+    write();
+  }
+  writeFileSync(resolve(app.options.silgi.serverDir, "index.ts"), `${indexImports.map((i) => `export * from '${i}'`).join("\n")}
+`, "utf8");
+  if (changedTemplates.length) {
+    await app.callHook("app:templatesGenerated", app, changedTemplates, options);
+  }
+}
+async function compileTemplate(template, ctx) {
+  delete ctx.utils;
+  if (template.src) {
+    try {
+      return await promises.readFile(template.src, "utf-8");
+    } catch (err) {
+      logger.error(`[nuxt] Error reading template from \`${template.src}\``);
+      throw err;
+    }
+  }
+  if (template.getContents) {
+    return template.getContents({
+      ...ctx,
+      options: template.options
+    });
+  }
+  throw new Error(`[nuxt] Invalid template. Templates must have either \`src\` or \`getContents\`: ${JSON.stringify(template)}`);
+}
+
+export { generateApp, logger };

package/dist/cli/core/scan.mjs

@@ -0,0 +1,40 @@
+import { globby } from 'globby';
+import { join, relative } from 'pathe';
+import 'ufo';
+
+const GLOB_SCAN_PATTERN = "**/*.{js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+async function scanAndSyncOptions(silgi) {
+  const scannedModules = await scanModules(silgi);
+  silgi.options.modules = silgi.options.modules || [];
+  for (const modPath of scannedModules) {
+    if (!silgi.options.modules.includes(modPath)) {
+      silgi.options.modules.push(modPath);
+    }
+  }
+}
+async function scanModules(silgi) {
+  const files = await scanFiles(silgi, "silgi/modules");
+  return files.map((f) => f.fullPath);
+}
+async function scanFiles(silgi, name) {
+  const files = await Promise.all(
+    silgi.options.scanDirs.map((dir) => scanDir(silgi, dir, name))
+  ).then((r) => r.flat());
+  return files;
+}
+async function scanDir(silgi, dir, name) {
+  const fileNames = await globby(join(name, GLOB_SCAN_PATTERN), {
+    cwd: dir,
+    dot: true,
+    ignore: silgi.options.ignore,
+    absolute: true
+  });
+  return fileNames.map((fullPath) => {
+    return {
+      fullPath,
+      path: relative(join(dir, name), fullPath)
+    };
+  }).sort((a, b) => a.path.localeCompare(b.path));
+}
+
+export { GLOB_SCAN_PATTERN, scanAndSyncOptions, scanModules };

package/dist/cli/core/silgi.mjs

@@ -0,0 +1,77 @@
+import { consola } from 'consola';
+import { createHooks, createDebugger } from 'hookable';
+import { join } from 'pathe';
+import { loadOptions, silgiCLICtx } from 'silgi/core';
+import { runtimeDir } from 'silgi/runtime/meta';
+import { createUnimport } from 'unimport';
+import { registerModuleExportScan } from '../module/exportScan.mjs';
+import { installModules } from '../module/install.mjs';
+import { scanModules } from '../module/scan.mjs';
+import { scanFiles } from '../utils/scan.mjs';
+import { createStorageCLI } from '../utils/storage.mjs';
+import { generateApp } from './app.mjs';
+import { scanAndSyncOptions } from './scan.mjs';
+
+async function createSilgiCLI(config = {}, opts = {}) {
+  const options = await loadOptions(config, opts);
+  const hooks = createHooks();
+  const silgi = {
+    modulesURIs: {},
+    scannedURIs: /* @__PURE__ */ new Map(),
+    services: {},
+    uris: {},
+    shareds: {},
+    schemas: {},
+    unimport: void 0,
+    options,
+    hooks,
+    // vfs: {}
+    _requiredModules: {},
+    logger: consola.withTag("silgi"),
+    close: () => silgi.hooks.callHook("close", silgi),
+    storage: void 0,
+    scanModules: [],
+    templates: [],
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    async updateConfig(_config) {
+    }
+  };
+  if (silgiCLICtx.tryUse()) {
+    silgiCLICtx.unset();
+    silgiCLICtx.set(silgi);
+  } else {
+    silgiCLICtx.set(silgi);
+    silgi.hook("close", () => silgiCLICtx.unset());
+  }
+  if (silgi.options.debug) {
+    createDebugger(silgi.hooks, { tag: "silgi" });
+    silgi.options.plugins.push({
+      path: join(runtimeDir, "internal/debug"),
+      packageImport: "silgi/runtime/internal/debug"
+    });
+  }
+  await scanAndSyncOptions(silgi);
+  await scanModules(silgi);
+  await scanFiles(silgi);
+  silgi.storage = await createStorageCLI(silgi);
+  silgi.hooks.hook("close", async () => {
+    await silgi.storage.dispose();
+  });
+  if (silgi.options.logLevel !== void 0) {
+    silgi.logger.level = silgi.options.logLevel;
+  }
+  silgi.hooks.addHooks(silgi.options.hooks);
+  await installModules(silgi);
+  await silgi.hooks.callHook("scanFiles:done", silgi);
+  await generateApp(silgi);
+  if (silgi.options.imports) {
+    silgi.unimport = createUnimport(silgi.options.imports);
+    await silgi.unimport.init();
+  }
+  await registerModuleExportScan(silgi);
+  return silgi;
+}
+
+export { createSilgiCLI };

package/dist/cli/core/storage.mjs

@@ -0,0 +1,11 @@
+async function generateSilgiStorageBaseType(silgi) {
+  silgi.hook("prepare:schema.ts", async (options) => {
+    if (silgi.options.storage) {
+      for (const [key, _value] of Object.entries(silgi.options.storage)) {
+        options.storeBase.push(key);
+      }
+    }
+  });
+}
+
+export { generateSilgiStorageBaseType };

package/dist/cli/core/templates.mjs

@@ -0,0 +1,29 @@
+const vueShim = {
+  filename: "types/vue-shim.d.ts",
+  getContents: ({ app }) => {
+    if (!app.options.typescript.shim) {
+      return "";
+    }
+    return [
+      "declare module '*.vue' {",
+      "  import { DefineComponent } from 'vue'",
+      "  const component: DefineComponent<{}, {}, any>",
+      "  export default component",
+      "}"
+    ].join("\n");
+  }
+};
+const pluginsDeclaration = {
+  filename: "types/plugins.d.ts",
+  getContents: async () => {
+    return `
+      declare module 'nuxt' {
+        interface NuxtApp {
+          $myPlugin: any;
+        }
+      }
+    `;
+  }
+};
+
+export { pluginsDeclaration, vueShim };

package/dist/cli/index.mjs

@@ -1,6 +1,6 @@
 import { defineCommand, runMain } from 'citty';
 import consola from 'consola';
-import { p as packageJson } from '../_chunks/index.mjs';
+import packageJson from '../package.json.mjs';
 
 const main = defineCommand({
   meta: {
@@ -15,8 +15,8 @@ const main = defineCommand({
     }
   },
   subCommands: {
-    prepare: () => import('./prepare.mjs').then((m) => m.default),
-    init: () => import('./init.mjs').then((m) => m.default)
+    prepare: () => import('./commands/prepare.mjs').then((m) => m.default),
+    init: () => import('./commands/init.mjs').then((m) => m.default)
   },
   run({ args }) {
     consola.info("Silgi CLI , --help for more info");

package/dist/cli/module/exportScan.mjs

@@ -0,0 +1,69 @@
+import { pascalCase } from 'scule';
+import { relativeWithDot } from 'silgi/kit';
+
+async function registerModuleExportScan(silgi) {
+  silgi.hook("prepare:schema.ts", async (options) => {
+    for (const module of silgi.scanModules) {
+      const exports = module.meta.exports;
+      if (!exports?.length)
+        continue;
+      const configKey = module.meta.configKey;
+      const moduleName = module.meta.name || module.meta._packageName;
+      options.importItems[configKey] = {
+        import: [],
+        from: module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath)
+      };
+      const exportedTypes = exports.filter((exp) => exp.type).map((exp) => exp.name);
+      if (exportedTypes.includes("ModuleOptions")) {
+        const importName = pascalCase(`${configKey}Config`);
+        options.importItems[configKey].import.push({
+          name: `ModuleOptions as ${importName}`,
+          type: true
+        });
+        options.configs.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeContext")) {
+        const importName = pascalCase(`${configKey}Context`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeContext as ${importName}`,
+          type: true
+        });
+        options.contexts.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeMethods")) {
+        const importName = pascalCase(`${configKey}Method`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeMethods as ${importName}`,
+          type: true
+        });
+        options.methods.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeShared")) {
+        const importName = pascalCase(`${configKey}Shared`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeShared as ${importName}`,
+          type: true
+        });
+        options.shareds.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleHooks")) {
+        const importName = pascalCase(`${configKey}Hooks`);
+        options.importItems[configKey].import.push({
+          name: `ModuleHooks as ${importName}`,
+          type: true
+        });
+        options.hooks.push({ key: configKey, value: importName });
+      }
+      if (exportedTypes.includes("ModuleRuntimeHooks")) {
+        const importName = pascalCase(`${configKey}RuntimeHooks`);
+        options.importItems[configKey].import.push({
+          name: `ModuleRuntimeHooks as ${importName}`,
+          type: true
+        });
+        options.runtimeHooks.push({ key: configKey, value: importName });
+      }
+    }
+  });
+}
+
+export { registerModuleExportScan };

package/dist/cli/module/install.mjs

@@ -0,0 +1,52 @@
+import { createJiti } from 'dev-jiti';
+import { useSilgiCLI } from 'silgi/core';
+import { hasInstalledModule } from '../utils/compatibility.mjs';
+
+async function loadSilgiModuleInstance(silgiModule) {
+  if (typeof silgiModule === "string") {
+    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
+  }
+  if (typeof silgiModule !== "function") {
+    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
+  }
+  return { silgiModule };
+}
+async function installModules(silgi) {
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias
+  });
+  for (const module of silgi.scanModules) {
+    if (hasInstalledModule(module.meta.configKey)) {
+      silgi.logger.info(`Module ${module.meta.configKey} installed`);
+    }
+    try {
+      const silgiModule = await jiti.import(module.entryPath, {
+        default: true,
+        conditions: silgi.options.conditions
+      });
+      if (silgiModule.name !== "silgiNormalizedModule") {
+        silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
+        continue;
+      }
+      await installModule(silgiModule, silgi);
+    } catch (err) {
+      silgi.logger.error(err);
+    }
+  }
+}
+async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions) {
+  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
+  const res = await silgiModule({}, silgi) ?? {};
+  if (res === false) {
+    return false;
+  }
+  const metaData = await silgiModule.getMeta?.();
+  const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
+  if (installedModule) {
+    installedModule.installed = true;
+  } else {
+    throw new Error(`Module ${metaData?.name} not found`);
+  }
+}
+
+export { installModules, loadSilgiModuleInstance };

package/dist/cli/module/scan.mjs

@@ -0,0 +1,141 @@
+import { existsSync, promises } from 'node:fs';
+import { pathToFileURL, fileURLToPath } from 'node:url';
+import { consola } from 'consola';
+import { createJiti } from 'dev-jiti';
+import { resolve as resolve$1 } from 'mlly';
+import { resolve, join, isAbsolute } from 'pathe';
+import { resolveAlias, resolvePath } from 'silgi/kit';
+import { isRelative } from 'ufo';
+import { scanExports } from 'unimport';
+
+const logger = consola;
+async function _resolveSilgiModule(mod, silgi) {
+  let _url;
+  let buildTimeModuleMeta = {};
+  const jiti = createJiti(silgi.options.rootDir, {
+    alias: silgi.options.alias
+  });
+  if (typeof mod === "string") {
+    const paths = /* @__PURE__ */ new Set();
+    mod = resolveAlias(mod, silgi.options.alias);
+    if (isRelative(mod)) {
+      mod = resolve(silgi.options.rootDir, mod);
+    }
+    paths.add(join(mod, "module"));
+    paths.add(mod);
+    for (const path of paths) {
+      try {
+        const src = isAbsolute(path) ? pathToFileURL(await resolvePath(path, { fallbackToOriginal: false, extensions: silgi.options.extensions })).href : await resolve$1(path, { url: silgi.options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: silgi.options.extensions });
+        mod = await jiti.import(src, {
+          default: true,
+          conditions: silgi.options.conditions
+        });
+        _url = fileURLToPath(new URL(src));
+        const moduleMetadataPath = new URL("module.json", src);
+        if (existsSync(moduleMetadataPath)) {
+          buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
+        } else {
+          if (typeof mod === "function") {
+            const meta = await mod.getMeta?.();
+            const _exports = await scanExports(_url, true);
+            buildTimeModuleMeta = {
+              ...meta,
+              exports: _exports.map(({ from, ...rest }) => rest)
+            };
+          }
+        }
+        break;
+      } catch (error) {
+        const code = error.code;
+        if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
+          continue;
+        }
+        logger.error(`Error while importing module \`${mod}\`: ${error}`);
+        throw error;
+      }
+    }
+  }
+  if (!buildTimeModuleMeta) {
+    throw new Error(`Module ${mod} is not a valid Silgi module`);
+  }
+  if (typeof mod === "function") {
+    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
+      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
+    }
+    silgi.scanModules.push({
+      meta: buildTimeModuleMeta,
+      entryPath: _url,
+      installed: false,
+      options: await mod.getOptions?.() || {}
+    });
+  }
+}
+async function scanModules(silgi) {
+  const _modules = [
+    ...silgi.options._modules,
+    ...silgi.options.modules
+  ];
+  for await (const mod of _modules) {
+    await _resolveSilgiModule(mod, silgi);
+  }
+  const moduleMap = new Map(
+    silgi.scanModules.map((m) => [m.meta?.configKey, m])
+  );
+  const graph = createDependencyGraph(silgi.scanModules);
+  const sortedKeys = topologicalSort(graph);
+  const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
+  silgi.scanModules = modules;
+}
+function createDependencyGraph(modules) {
+  const graph = /* @__PURE__ */ new Map();
+  modules.forEach((module) => {
+    const key = module.meta?.configKey;
+    if (key) {
+      graph.set(key, /* @__PURE__ */ new Set());
+    }
+  });
+  modules.forEach((module) => {
+    const key = module.meta?.configKey;
+    const deps = module.meta?.dependencies || [];
+    if (key && deps.length > 0) {
+      const modulesDeps = graph.get(key) || /* @__PURE__ */ new Set();
+      deps.forEach((dep) => {
+        if (graph.has(dep)) {
+          modulesDeps.add(dep);
+        }
+      });
+      graph.set(key, modulesDeps);
+    }
+  });
+  return graph;
+}
+function topologicalSort(graph) {
+  const visited = /* @__PURE__ */ new Set();
+  const temp = /* @__PURE__ */ new Set();
+  const order = [];
+  function visit(node) {
+    if (temp.has(node))
+      throw new Error(`Circular dependency detected: ${node}`);
+    if (visited.has(node))
+      return;
+    temp.add(node);
+    const deps = graph.get(node) || /* @__PURE__ */ new Set();
+    for (const dep of deps) {
+      visit(dep);
+    }
+    temp.delete(node);
+    visited.add(node);
+    order.unshift(node);
+  }
+  for (const [node, deps] of graph.entries()) {
+    if (deps.size === 0 && !visited.has(node))
+      visit(node);
+  }
+  for (const node of graph.keys()) {
+    if (!visited.has(node))
+      visit(node);
+  }
+  return order;
+}
+
+export { logger, scanModules };

package/dist/cli/{compatibility.mjs → utils/compatibility.mjs}

@@ -27,4 +27,4 @@ function hasInstalledModule(moduleKey, silgi = useSilgiCLI()) {
   return find?.installed ?? false;
 }
 
-export { checkSilgiCompatibility as c, hasInstalledModule as h };
+export { checkSilgiCompatibility, hasInstalledModule, normalizeSemanticVersion };

package/dist/cli/utils/generateRouterDTS.mjs

@@ -0,0 +1,84 @@
+import { promises } from 'node:fs';
+import { resolve } from 'pathe';
+
+async function generateRouterDTS(silgi) {
+  silgi.hook("finish:types", async (data) => {
+    const uris = data.object.uris;
+    const subPath = "srn";
+    const groupedPaths = /* @__PURE__ */ new Map();
+    Object.entries(uris || {}).forEach(([key, params]) => {
+      const [service, resource, method, action] = key.split("/");
+      const basePath = params ? `${subPath}/${service}/${resource}/${action}/${params}` : `${subPath}/${service}/${resource}/${action}`;
+      const fullPath = `${subPath}/${service}/${resource}/${action}`;
+      if (!groupedPaths.has(basePath)) {
+        groupedPaths.set(basePath, /* @__PURE__ */ new Map());
+      }
+      groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
+    });
+    const keys = [
+      "  keys: {",
+      Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
+        return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
+      ${method}: '/${path}'`).join(",")}
+    }`;
+      }).join(",\n"),
+      "  }",
+      ""
+    ].join("\n");
+    const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
+      const [service, resource, method, action] = key.split("/");
+      const routePath = `${subPath}/${service}/${resource}/${action}`;
+      if (!acc[routePath]) {
+        acc[routePath] = {};
+      }
+      acc[routePath][method] = {
+        input: `ExtractInputFromURI<'${key}'>`,
+        output: `ExtractOutputFromURI<'${key}'>`,
+        params: `ExtractRouterParamsFromURI<'${key}'>['params']`
+      };
+      return acc;
+    }, {});
+    const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
+      const methodEntries = Object.entries(methods).map(([method, { input, output, params }]) => {
+        return `    '${method}': {
+      input: ${input},
+      output: ${output}
+      params: ${params}
+    }`;
+      }).join(",\n");
+      return `  '/${path}': {
+${methodEntries}
+  }`;
+    });
+    const nitro = [
+      "declare module 'nitropack/types' {",
+      "  interface InternalApi extends RouterTypes {}",
+      "}"
+    ];
+    const content = [
+      keys.slice(0, -1),
+      // son satırdaki boş satırı kaldır
+      ...routerTypes
+    ].join(",\n");
+    const context = [
+      "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractRouterParamsFromURI } from 'silgi/types'",
+      "",
+      "export interface RouterTypes {",
+      content,
+      "}",
+      "",
+      "declare module 'silgi/types' {",
+      "  interface SilgiRouterTypes extends RouterTypes {",
+      "  }",
+      "}",
+      "",
+      silgi.options.preset === "h3" || silgi.options.preset === "nitro" ? nitro.join("\n") : "",
+      "",
+      "export {}"
+    ].join("\n");
+    const outputPath = resolve(silgi.options.build.typesDir, "silgi-routes.d.ts");
+    await promises.writeFile(outputPath, context);
+  });
+}
+
+export { generateRouterDTS };

package/dist/cli/utils/ignore.mjs

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from 'node:fs';
+import ignore from 'ignore';
+import { relative, join } from 'pathe';
+
+function resolveIgnorePatterns(silgi, relativePath) {
+  if (!silgi) {
+    return [];
+  }
+  const ignorePatterns = silgi.options.ignore.flatMap((s) => resolveGroupSyntax(s));
+  const nuxtignoreFile = join(silgi.options.rootDir, ".nuxtignore");
+  if (existsSync(nuxtignoreFile)) {
+    const contents = readFileSync(nuxtignoreFile, "utf-8");
+    ignorePatterns.push(...contents.trim().split(/\r?\n/));
+  }
+  return ignorePatterns;
+}
+function isIgnored(pathname, silgi, _stats) {
+  if (!silgi) {
+    return false;
+  }
+  if (!silgi._ignore) {
+    silgi._ignore = ignore(silgi.options.ignoreOptions);
+    silgi._ignore.add(resolveIgnorePatterns(silgi));
+  }
+  const relativePath = relative(silgi.options.rootDir, pathname);
+  if (relativePath[0] === "." && relativePath[1] === ".") {
+    return false;
+  }
+  return !!(relativePath && silgi._ignore.ignores(relativePath));
+}
+function resolveGroupSyntax(group) {
+  let groups = [group];
+  while (groups.some((group2) => group2.includes("{"))) {
+    groups = groups.flatMap((group2) => {
+      const [head, ...tail] = group2.split("{");
+      if (tail.length) {
+        const [body = "", ...rest] = tail.join("{").split("}");
+        return body.split(",").map((part) => `${head}${part}${rest.join("")}`);
+      }
+      return group2;
+    });
+  }
+  return groups;
+}
+
+export { isIgnored, resolveGroupSyntax, resolveIgnorePatterns };