@opexa/portal-components 0.0.31 → 0.0.33

package/dist/config.d.ts

@@ -0,0 +1,272 @@
+import type { NextConfig } from 'next';
+export declare function extendConfig(config: NextConfig): {
+    images: {
+        remotePatterns: (URL | import("next/dist/shared/lib/image-config").RemotePattern | {
+            hostname: string;
+            protocol: string;
+        })[];
+        deviceSizes?: number[] | undefined;
+        imageSizes?: number[] | undefined;
+        loader?: "default" | "imgix" | "cloudinary" | "akamai" | "custom" | undefined;
+        path?: string | undefined;
+        loaderFile?: string | undefined;
+        domains?: string[] | undefined;
+        disableStaticImages?: boolean | undefined;
+        minimumCacheTTL?: number | undefined;
+        formats?: ("image/avif" | "image/webp")[] | undefined;
+        dangerouslyAllowSVG?: boolean | undefined;
+        contentSecurityPolicy?: string | undefined;
+        contentDispositionType?: "inline" | "attachment" | undefined;
+        localPatterns?: import("next/dist/shared/lib/image-config").LocalPattern[] | undefined;
+        qualities?: number[] | undefined;
+        unoptimized?: boolean | undefined;
+    };
+    experimental: {
+        nodeMiddleware: boolean;
+        adapterPath?: string;
+        useSkewCookie?: boolean;
+        cacheHandlers?: {
+            default?: string;
+            remote?: string;
+            static?: string;
+            [handlerName: string]: string | undefined;
+        };
+        multiZoneDraftMode?: boolean;
+        appNavFailHandling?: boolean;
+        prerenderEarlyExit?: boolean;
+        linkNoTouchStart?: boolean;
+        caseSensitiveRoutes?: boolean;
+        clientSegmentCache?: boolean | "client-only";
+        dynamicOnHover?: boolean;
+        appDocumentPreloading?: boolean;
+        preloadEntriesOnStart?: boolean;
+        strictNextHead?: boolean;
+        clientRouterFilter?: boolean;
+        clientRouterFilterRedirects?: boolean;
+        staleTimes?: {
+            dynamic?: number;
+            static?: number;
+        };
+        cacheLife?: {
+            [profile: string]: {
+                stale?: number;
+                revalidate?: number;
+                expire?: number;
+            };
+        };
+        clientRouterFilterAllowedRate?: number;
+        externalMiddlewareRewritesResolve?: boolean;
+        extensionAlias?: Record<string, any>;
+        allowedRevalidateHeaderKeys?: string[];
+        fetchCacheKeyPrefix?: string;
+        imgOptConcurrency?: number | null;
+        imgOptTimeoutInSeconds?: number;
+        imgOptMaxInputPixels?: number;
+        imgOptSequentialRead?: boolean | null;
+        optimisticClientCache?: boolean;
+        expireTime?: number;
+        middlewarePrefetch?: "strict" | "flexible";
+        manualClientBasePath?: boolean;
+        cssChunking?: boolean | "strict";
+        disablePostcssPresetEnv?: boolean;
+        cpus?: number;
+        memoryBasedWorkersCount?: boolean;
+        proxyTimeout?: number;
+        isrFlushToDisk?: boolean;
+        workerThreads?: boolean;
+        optimizeCss?: boolean | Record<string, unknown>;
+        nextScriptWorkers?: boolean;
+        scrollRestoration?: boolean;
+        externalDir?: boolean;
+        amp?: {
+            optimizer?: any;
+            validator?: string;
+            skipValidation?: boolean;
+        };
+        disableOptimizedLoading?: boolean;
+        gzipSize?: boolean;
+        craCompat?: boolean;
+        esmExternals?: boolean | "loose";
+        fullySpecified?: boolean;
+        urlImports?: NonNullable<import("next/dist/compiled/webpack/webpack").webpack.Configuration["experiments"]>["buildHttp"];
+        swcTraceProfiling?: boolean;
+        forceSwcTransforms?: boolean;
+        swcPlugins?: Array<[string, Record<string, unknown>]>;
+        largePageDataBytes?: number;
+        fallbackNodePolyfills?: false;
+        sri?: {
+            algorithm?: import("next/dist/build/webpack/plugins/subresource-integrity-plugin").SubresourceIntegrityAlgorithm;
+        };
+        webVitalsAttribution?: Array<typeof import("next/dist/shared/lib/utils").WEB_VITALS[number]>;
+        optimizePackageImports?: string[];
+        optimizeServerReact?: boolean;
+        turbo?: import("next/dist/server/config-shared").DeprecatedExperimentalTurboOptions;
+        turbopackMemoryLimit?: number;
+        turbopackMinify?: boolean;
+        turbopackPersistentCaching?: boolean;
+        turbopackSourceMaps?: boolean;
+        turbopackTreeShaking?: boolean;
+        mdxRs?: boolean | {
+            development?: boolean;
+            jsx?: boolean;
+            jsxRuntime?: string;
+            jsxImportSource?: string;
+            providerImportSource?: string;
+            mdxType?: "gfm" | "commonmark";
+        };
+        typedRoutes?: boolean;
+        typedEnv?: boolean;
+        parallelServerCompiles?: boolean;
+        parallelServerBuildTraces?: boolean;
+        webpackBuildWorker?: boolean;
+        webpackMemoryOptimizations?: boolean;
+        clientTraceMetadata?: string[];
+        ppr?: import("next/dist/server/lib/experimental/ppr").ExperimentalPPRConfig;
+        taint?: boolean;
+        routerBFCache?: boolean;
+        removeUncaughtErrorAndRejectionListeners?: boolean;
+        serverActions?: {
+            bodySizeLimit?: import("next").SizeLimit;
+            allowedOrigins?: string[];
+        };
+        serverMinification?: boolean;
+        enablePrerenderSourceMaps?: boolean;
+        serverSourceMaps?: boolean;
+        useWasmBinary?: boolean;
+        useLightningcss?: boolean;
+        useEarlyImport?: boolean;
+        viewTransition?: boolean;
+        testProxy?: boolean;
+        defaultTestRunner?: import("next/dist/cli/next-test").SupportedTestRunners;
+        allowDevelopmentBuild?: true;
+        bundlePagesExternals?: boolean;
+        serverComponentsExternalPackages?: string[];
+        reactCompiler?: boolean | import("next/dist/server/config-shared").ReactCompilerOptions;
+        staticGenerationRetryCount?: number;
+        staticGenerationMaxConcurrency?: number;
+        staticGenerationMinPagesPerWorker?: number;
+        serverComponentsHmrCache?: boolean;
+        dynamicIO?: boolean;
+        inlineCss?: boolean;
+        authInterrupts?: boolean;
+        useCache?: boolean;
+        slowModuleDetection?: {
+            buildTimeThresholdMs: number;
+        };
+        globalNotFound?: boolean;
+        devtoolSegmentExplorer?: boolean;
+    };
+    allowedDevOrigins?: string[];
+    exportPathMap?: (defaultMap: import("next/dist/server/config-shared").ExportPathMap, ctx: {
+        dev: boolean;
+        dir: string;
+        outDir: string | null;
+        distDir: string;
+        buildId: string;
+    }) => Promise<import("next/dist/server/config-shared").ExportPathMap> | import("next/dist/server/config-shared").ExportPathMap;
+    i18n?: import("next/dist/server/config-shared").I18NConfig | null;
+    eslint?: import("next/dist/server/config-shared").ESLintConfig;
+    typescript?: import("next/dist/server/config-shared").TypeScriptConfig;
+    headers?: () => Promise<import("next/dist/lib/load-custom-routes").Header[]>;
+    rewrites?: () => Promise<import("next/dist/lib/load-custom-routes").Rewrite[] | {
+        beforeFiles?: import("next/dist/lib/load-custom-routes").Rewrite[];
+        afterFiles?: import("next/dist/lib/load-custom-routes").Rewrite[];
+        fallback?: import("next/dist/lib/load-custom-routes").Rewrite[];
+    }>;
+    redirects?: () => Promise<import("next/dist/lib/load-custom-routes").Redirect[]>;
+    excludeDefaultMomentLocales?: boolean;
+    webpack?: import("next/dist/server/config-shared").NextJsWebpackConfig | null;
+    trailingSlash?: boolean;
+    env?: Record<string, string | undefined>;
+    distDir?: string;
+    cleanDistDir?: boolean;
+    assetPrefix?: string;
+    cacheHandler?: string | undefined;
+    cacheMaxMemorySize?: number;
+    useFileSystemPublicRoutes?: boolean;
+    generateBuildId?: () => string | null | Promise<string | null>;
+    generateEtags?: boolean;
+    pageExtensions?: string[];
+    compress?: boolean;
+    poweredByHeader?: boolean;
+    devIndicators?: false | {
+        appIsrStatus?: boolean;
+        buildActivity?: boolean;
+        buildActivityPosition?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+        position?: "top-left" | "top-right" | "bottom-left" | "bottom-right";
+    };
+    onDemandEntries?: {
+        maxInactiveAge?: number;
+        pagesBufferLength?: number;
+    };
+    amp?: {
+        canonicalBase?: string;
+    };
+    deploymentId?: string;
+    basePath?: string;
+    sassOptions?: {
+        implementation?: string;
+        [key: string]: any;
+    };
+    productionBrowserSourceMaps?: boolean;
+    reactProductionProfiling?: boolean;
+    reactStrictMode?: boolean | null;
+    reactMaxHeadersLength?: number;
+    publicRuntimeConfig?: {
+        [key: string]: any;
+    };
+    serverRuntimeConfig?: {
+        [key: string]: any;
+    };
+    httpAgentOptions?: {
+        keepAlive?: boolean;
+    };
+    staticPageGenerationTimeout?: number;
+    crossOrigin?: "anonymous" | "use-credentials";
+    compiler?: {
+        reactRemoveProperties?: boolean | {
+            properties?: string[];
+        };
+        relay?: {
+            src: string;
+            artifactDirectory?: string;
+            language?: "typescript" | "javascript" | "flow";
+            eagerEsModules?: boolean;
+        };
+        removeConsole?: boolean | {
+            exclude?: string[];
+        };
+        styledComponents?: boolean | import("next/dist/server/config-shared").StyledComponentsConfig;
+        emotion?: boolean | import("next/dist/server/config-shared").EmotionConfig;
+        styledJsx?: boolean | {
+            useLightningcss?: boolean;
+        };
+        define?: Record<string, string>;
+        defineServer?: Record<string, string>;
+        runAfterProductionCompile?: (metadata: {
+            projectDir: string;
+            distDir: string;
+        }) => Promise<void>;
+    };
+    output?: "standalone" | "export";
+    transpilePackages?: string[];
+    turbopack?: import("next/dist/server/config-shared").TurbopackOptions;
+    skipMiddlewareUrlNormalize?: boolean;
+    skipTrailingSlashRedirect?: boolean;
+    modularizeImports?: Record<string, {
+        transform: string | Record<string, string>;
+        preventFullImport?: boolean;
+        skipDefaultConversion?: boolean;
+    }>;
+    logging?: import("next/dist/server/config-shared").LoggingConfig | false;
+    expireTime?: number;
+    bundlePagesRouterDependencies?: boolean;
+    serverExternalPackages?: string[];
+    outputFileTracingRoot?: string;
+    outputFileTracingExcludes?: Record<string, string[]>;
+    outputFileTracingIncludes?: Record<string, string[]>;
+    watchOptions?: {
+        pollIntervalMs?: number;
+    };
+    htmlLimitedBots?: RegExp;
+};

package/dist/config.js

@@ -0,0 +1,39 @@
+export function extendConfig(config) {
+    return {
+        ...config,
+        images: {
+            ...config.images,
+            remotePatterns: [
+                ...(config.images?.remotePatterns ?? []),
+                {
+                    hostname: 'static.opexa.io',
+                    protocol: 'https',
+                },
+                {
+                    hostname: 'static.development.opexa.io',
+                    protocol: 'https',
+                },
+                {
+                    hostname: 'assets.opexacms.io',
+                    protocol: 'https',
+                },
+                {
+                    hostname: 'assets.development.opexacms.io',
+                    protocol: 'https',
+                },
+                {
+                    hostname: 's3.ap-east-1.amazonaws.com',
+                    protocol: 'https',
+                },
+                {
+                    hostname: 'images.pexels.com',
+                    protocol: 'https',
+                },
+            ],
+        },
+        experimental: {
+            ...config.experimental,
+            nodeMiddleware: true,
+        },
+    };
+}

package/dist/handlers.d.ts

@@ -10,17 +10,17 @@ export declare const GET: (request: NextRequest, { params }: {
         auth: string[];
     }>;
 }) => Promise<NextResponse<{
-    ok: false;
-    message: string;
-} | {
-    ok: true;
-    data: GetSessionResponse;
-}> | NextResponse<{
     ok: true;
     data?: never;
 } | {
     ok: false;
     message: string;
+}> | NextResponse<{
+    ok: false;
+    message: string;
+} | {
+    ok: true;
+    data: GetSessionResponse;
 }>>;
 export declare const DELETE: (request: NextRequest, { params }: {
     params: Promise<{

package/dist/handlers.js

@@ -35,6 +35,25 @@ const AuthenticateDefinition = z.object({
 export const GET = async (request, { params }) => {
     const { auth } = await params;
     const path = auth[0];
+    /*
+     *
+     * GET -> /api/health
+     * GET -> /api/healthcheck
+     * GET -> /api/health-check
+     *
+     */
+    if (/^health(-?check)?$/i.test(path)) {
+        return NextResponse.json({
+            ok: true,
+        }, {
+            headers: {
+                'Access-Control-Allow-Origin': '*',
+                'Cache-Control': 'no-cache, no-store, must-revalidate',
+                Pragma: 'no-cache',
+                Expires: '0',
+            },
+        });
+    }
     /*
      *
      * GET -> /api/sessions