hanzio 1.1.0 → 2.0.0

package/dist/secrets/infisical-config.d.ts

@@ -0,0 +1,17 @@
+import type { SecretRequestOptions } from './deadline';
+/** Project scope shared by the public Infisical loaders. */
+export type InfisicalProjectOptions = {
+    readonly projectId: string;
+    /** Scope CLI user authentication; machine identities already have an organization. */
+    readonly organizationId: string;
+    readonly siteUrl?: string;
+    readonly secretPath?: string;
+};
+export type InfisicalScope<K extends string> = InfisicalProjectOptions & SecretRequestOptions & {
+    readonly keys: readonly K[];
+    readonly environment: string;
+    readonly siteUrl: string;
+};
+export declare function validateInfisicalScope(options: InfisicalScope<string>): void;
+/** Validate at configuration time, including for JavaScript callers and local-only loads. */
+export declare function validateInfisicalOrganizationId(organizationId: unknown): void;

package/dist/secrets/infisical-session.d.ts

@@ -0,0 +1,4 @@
+/** Read routing metadata only. JWT signature and permissions are verified by Infisical. */
+export declare function parseInfisicalSessionToken(token: string): {
+    organizationId?: string;
+};

package/dist/secrets/infisical.d.ts

@@ -1,19 +1,14 @@
-import type { SecretEnvironment } from '.';
+import { type InfisicalScope } from './infisical-config';
 export declare const DEFAULT_INFISICAL_SITE_URL = "https://eu.infisical.com";
-export declare function fetchInfisicalSecrets<SecretKey extends string>({ keys, projectId, environment, siteUrl, clientId, clientSecret }: {
-    readonly keys: readonly SecretKey[];
-    readonly projectId: string;
-    readonly environment: SecretEnvironment;
-    readonly siteUrl: string;
+export type InfisicalAuthMode = 'auto' | 'http' | 'cli';
+export declare function fetchInfisicalSecrets<K extends string>(options: InfisicalScope<K> & {
     readonly clientId: string;
     readonly clientSecret: string;
-}): Promise<Partial<Record<SecretKey, string>>>;
-export type LoadInfisicalSecretsFromEnvOptions<SecretKey extends string> = {
-    readonly keys: readonly SecretKey[];
-    readonly projectId: string;
-    readonly environment: SecretEnvironment;
-    readonly siteUrl: string;
+}): Promise<Partial<Record<K, string>>>;
+export type LoadInfisicalSecretsFromEnvOptions<K extends string> = InfisicalScope<K> & {
     readonly clientIdEnvKey: string;
     readonly clientSecretEnvKey: string;
+    readonly auth?: InfisicalAuthMode;
+    readonly reportSource?: (source: string) => void;
 };
-export declare function loadInfisicalSecrets<SecretKey extends string>({ keys, projectId, environment, siteUrl, clientIdEnvKey, clientSecretEnvKey }: LoadInfisicalSecretsFromEnvOptions<SecretKey>): Promise<Partial<Record<SecretKey, string>>>;
+export declare function loadInfisicalSecrets<K extends string>(options: LoadInfisicalSecretsFromEnvOptions<K>): Promise<Partial<Record<K, string>>>;

package/dist/secrets/loaders.d.ts

@@ -1,16 +1,9 @@
-import type { SecretSetLoader, SecretSetLoaderContext } from './index';
-/**
- * Reads secrets from a Cloudflare Worker `env` bindings object (or any similar
- * `Record`), for Workers where `process.env` is not populated. Pass the same
- * object you get as `env` in your fetch handler, or values you’d read from
- * `import { env } from "cloudflare:workers"` in your Worker bundle — this
- * package does not import that module.
- */
-export declare function cloudflareWorkerEnvLoader<SecretKey extends string>(workerEnv: Record<string, unknown>): SecretSetLoader<SecretKey>;
-export declare function infisicalLoader<SecretKey extends string>(config: {
-    readonly projectId: string;
+import { type InfisicalProjectOptions } from './infisical-config';
+import type { SecretSetLoader, SecretSetLoaderContext } from './core';
+export { cloudflareWorkerEnvLoader } from './worker-loader';
+export declare function infisicalLoader<SecretKey extends string>(config: InfisicalProjectOptions & {
     readonly clientId: string;
     readonly clientSecret: string;
-    readonly siteUrl?: string;
+    readonly timeoutMs?: number;
 }): SecretSetLoader<SecretKey>;
 export declare function processEnvLoader<SecretKey extends string>(_ctx: SecretSetLoaderContext<SecretKey>): Promise<Partial<Record<SecretKey, string>>>;

package/dist/secrets/vite.d.ts

@@ -1,9 +1,13 @@
-import type { SecretSet } from '.';
+import type { SecretSet } from './core';
 export type ViteSecretSetPlugin = {
     name: string;
     config: () => {
         define: Record<string, string>;
     };
 };
-export declare function getViteDefine<SecretKey extends string>(secretSet: SecretSet<SecretKey>): Record<string, string>;
-export declare function viteSecretSetPlugin<SecretKey extends string>(secretSet: SecretSet<SecretKey>): ViteSecretSetPlugin;
+export type ViteSecretSetOptions<K extends string> = {
+    /** Explicit acknowledgement that these values may be shipped to browsers. */
+    readonly publicKeys?: readonly K[];
+};
+export declare function getViteDefine<K extends string>(secretSet: Pick<SecretSet<K, unknown>, 'secrets'>, options?: ViteSecretSetOptions<K>): Record<string, string>;
+export declare function viteSecretSetPlugin<K extends string>(secretSet: Pick<SecretSet<K, unknown>, 'secrets'>, options?: ViteSecretSetOptions<K>): ViteSecretSetPlugin;

package/dist/secrets/worker-loader.d.ts

@@ -0,0 +1,9 @@
+import type { SecretSetLoader } from './core';
+/**
+ * Reads secrets from a Cloudflare Worker `env` bindings object (or any similar
+ * `Record`), for Workers where `process.env` is not populated. Pass the same
+ * object you get as `env` in your fetch handler, or values you’d read from
+ * `import { env } from "cloudflare:workers"` in your Worker bundle — this
+ * package does not import that module.
+ */
+export declare function cloudflareWorkerEnvLoader<SecretKey extends string>(workerEnv: Record<string, unknown>): SecretSetLoader<SecretKey>;

package/dist/secrets/worker.d.ts

@@ -0,0 +1,3 @@
+export * from './core';
+export { cloudflareWorkerEnvLoader } from './worker-loader';
+export type { SecretRequestOptions } from './deadline';

package/dist/sitemap/index.d.ts

@@ -1,14 +1,56 @@
-interface SitemapOptions {
-    filterIndexes?: string;
+/** Substring, RegExp, or predicate. */
+export type SitemapUrlFilter = string | RegExp | ((url: string) => boolean);
+export interface SitemapOptions {
+    /** Only follow nested sitemaps (from a `<sitemapindex>`) that match. */
+    filterIndexes?: SitemapUrlFilter;
+    /** Only keep page URLs (from a `<urlset>`) that match. */
+    filterUrls?: SitemapUrlFilter;
     concurrency?: number;
     maxDepth?: number;
+    /** Stop once this many URLs have been collected. */
+    maxUrls?: number;
+    /** Per-request timeout in ms. */
     timeout?: number;
+    userAgent?: string;
+    fetch?: typeof fetch;
+    /** Called for failed robots.txt/sitemap requests. Defaults to `console.warn`. */
+    onError?: (url: string, error: unknown) => void;
+    /** Drop page URLs that robots.txt disallows for `userAgent`. Defaults to `false`. */
+    respectRobots?: boolean;
 }
+/** The robots.txt rules that apply to one user agent. */
+export interface RobotsRules {
+    allow: string[];
+    disallow: string[];
+    /** Every `Sitemap:` line, whatever group it is in. */
+    sitemaps: string[];
+    crawlDelaySec?: number;
+}
+export interface SitemapEntry {
+    loc: string;
+    lastmod?: string;
+}
+/**
+ * Parses robots.txt for one user agent (RFC 9309): the groups naming its
+ * product token (case-insensitive, versions ignored), else the `*` groups.
+ * Several matching groups are merged. Empty `Allow`/`Disallow` values are dropped.
+ */
+export declare function parseRobotsTxt(body: string, userAgent?: string): RobotsRules;
+/**
+ * Whether `url` (absolute, or a path) may be crawled under `rules` (RFC 9309):
+ * the longest matching pattern wins and `Allow` wins a tie. Patterns support
+ * `*` and a trailing `$`, and match the path plus query string.
+ */
+export declare function isAllowedByRobots(rules: Pick<RobotsRules, 'allow' | 'disallow'>, url: string): boolean;
+/**
+ * Gets all entries (`loc` + optional `lastmod`) from a domain by discovering and crawling its sitemaps
+ * @param domain - The root domain (e.g., 'example.com' or 'https://example.com')
+ * @throws When no sitemap can be discovered
+ */
+export declare const getDomainSitemapEntries: (domain: string, options?: SitemapOptions) => Promise<SitemapEntry[]>;
 /**
  * Gets all URLs from a domain by discovering and crawling its sitemaps
- * @param domain - The root domain (e.g., 'https://example.com')
- * @param options - Configuration options for the crawler
- * @returns Promise<string[]> - Array of unique URLs found in the sitemap
+ * @param domain - The root domain (e.g., 'example.com' or 'https://example.com')
+ * @returns Array of unique URLs found in the sitemap
  */
 export declare const getDomainSitemap: (domain: string, options?: SitemapOptions) => Promise<string[]>;
-export {};