@bleedingdev/modern-js-app-tools 3.5.0-ultramodern.2 → 3.5.0-ultramodern.21

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-entry.mjs

@@ -223,6 +223,255 @@ function routeMatches(route, pathname) {
     const requestPath = normalizeRoutePath(pathname);
     return routePath === requestPath || '/' === routePath && route.isSSR || requestPath.startsWith(`${routePath}/`);
 }
+function getRouteI18nEntry(route) {
+    if (!route || 'string' != typeof route.entryName) return;
+    return MODERN_WORKER_MANIFEST.i18n?.entries?.[route.entryName];
+}
+function getRouteBasePath(route) {
+    const routePath = 'string' == typeof route?.urlPath ? normalizeRoutePath(route.urlPath) : '/';
+    return routePath || '/';
+}
+function getRouteRemainingPathname(route, pathname) {
+    const basePath = getRouteBasePath(route);
+    if ('/' === basePath) return pathname || '/';
+    if (!matchesPrefix(pathname, basePath)) return pathname || '/';
+    const remaining = pathname.slice(basePath.length);
+    return remaining ? remaining.startsWith('/') ? remaining : `/${remaining}` : '/';
+}
+function normalizeLanguage(value, languages) {
+    if ('string' != typeof value || '' === value.trim()) return null;
+    const normalized = value.trim().toLowerCase();
+    const exact = languages.find((language)=>language.toLowerCase() === normalized);
+    if (exact) return exact;
+    const baseLanguage = normalized.split(/[-_]/u)[0];
+    return languages.find((language)=>language.toLowerCase() === baseLanguage) || null;
+}
+function getLanguageFromPath(route, pathname, languages) {
+    const remainingPathname = getRouteRemainingPathname(route, pathname);
+    const firstSegment = remainingPathname.split('/').filter(Boolean)[0];
+    return normalizeLanguage(firstSegment, languages);
+}
+function safeDecodeURIComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    } catch  {
+        return value;
+    }
+}
+function detectLanguageFromCookie(cookieHeader, lookupCookie, languages) {
+    if (!cookieHeader) return null;
+    for (const cookiePart of cookieHeader.split(';')){
+        const [rawName, ...rawValue] = cookiePart.trim().split('=');
+        if (rawName === lookupCookie && 0 !== rawValue.length) return normalizeLanguage(safeDecodeURIComponent(rawValue.join('=')), languages);
+    }
+    return null;
+}
+function detectLanguageFromAcceptLanguage(acceptLanguage, languages) {
+    if (!acceptLanguage) return null;
+    return acceptLanguage.split(',').map((entry, index)=>{
+        const [rawRange, ...rawParameters] = entry.trim().split(';');
+        const qualityParameter = rawParameters.find((parameter)=>parameter.trim().startsWith('q='));
+        const quality = qualityParameter ? Number.parseFloat(qualityParameter.split('=')[1] || '') : 1;
+        return {
+            index,
+            language: normalizeLanguage(rawRange, languages),
+            quality: Number.isFinite(quality) ? quality : 1
+        };
+    }).filter((candidate)=>candidate.language && candidate.quality > 0).sort((left, right)=>right.quality - left.quality || left.index - right.index)[0]?.language || null;
+}
+function detectRedirectLanguage(request, entry) {
+    if (!entry.i18nextDetector) return null;
+    const url = new URL(request.url);
+    const detection = entry.detection || {};
+    const order = Array.isArray(detection.order) ? detection.order : [
+        'querystring',
+        'cookie',
+        'header'
+    ];
+    for (const method of order){
+        const language = 'querystring' === method ? normalizeLanguage(url.searchParams.get(detection.lookupQuerystring || 'lng'), entry.languages) : 'cookie' === method ? detectLanguageFromCookie(request.headers.get('cookie'), detection.lookupCookie || 'i18next', entry.languages) : 'header' === method ? detectLanguageFromAcceptLanguage(request.headers.get(detection.lookupHeader || 'accept-language'), entry.languages) : null;
+        if (language) return language;
+    }
+    return null;
+}
+function normaliseSlashes(pathname) {
+    const withoutDuplicateSlashes = pathname.replace(/\/+/g, '/');
+    const withLeadingSlash = withoutDuplicateSlashes.startsWith('/') ? withoutDuplicateSlashes : `/${withoutDuplicateSlashes}`;
+    return withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/u, '') : withLeadingSlash;
+}
+function normalisePathPattern(pathname) {
+    return normaliseSlashes(pathname).replace(/\[(.+?)\]/g, ':$1');
+}
+function stripLanguagePrefix(pathname, languages) {
+    const segments = pathname.split('/').filter(Boolean);
+    const firstSegment = segments[0];
+    if (firstSegment && normalizeLanguage(firstSegment, languages)) return `/${segments.slice(1).join('/')}` || '/';
+    return pathname || '/';
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function getPatternParamName(segment) {
+    return segment.slice(1).replace(/\?$/, '');
+}
+function compilePathPattern(pattern) {
+    const names = [];
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    const source = segments.map((segment)=>{
+        if (segment.startsWith(':')) {
+            names.push(getPatternParamName(segment));
+            return segment.endsWith('?') ? '(?:/([^/]+))?' : '/([^/]+)';
+        }
+        if ('*' === segment) {
+            names.push('*');
+            return '/(.*)';
+        }
+        return `/${escapeRegExp(segment)}`;
+    }).join('');
+    return {
+        names,
+        regexp: new RegExp(`^${source || '/'}$`)
+    };
+}
+function matchPathPattern(pathname, pattern) {
+    const { names, regexp } = compilePathPattern(pattern);
+    const match = regexp.exec(normaliseSlashes(pathname));
+    if (!match) return null;
+    const params = {};
+    for(let index = 0; index < names.length; index++)try {
+        params[names[index]] = decodeURIComponent(match[index + 1] || '');
+    } catch  {
+        return null;
+    }
+    return params;
+}
+function buildPathFromPattern(pattern, params) {
+    const path = normalisePathPattern(pattern).split('/').filter(Boolean).map((segment)=>{
+        if (segment.startsWith(':')) {
+            const param = params[getPatternParamName(segment)];
+            return param ? encodeURIComponent(param) : '';
+        }
+        if ('*' === segment) return params['*'] || '';
+        return segment;
+    }).filter(Boolean).join('/');
+    return `/${path}`;
+}
+function patternSpecificity(pattern) {
+    const segments = normalisePathPattern(pattern).split('/').filter(Boolean);
+    let staticSegments = 0;
+    let dynamicSegments = 0;
+    let splatSegments = 0;
+    for (const segment of segments)if ('*' === segment) splatSegments++;
+    else if (segment.startsWith(':')) dynamicSegments++;
+    else staticSegments++;
+    return {
+        dynamicSegments,
+        splatSegments,
+        staticSegments,
+        totalSegments: segments.length
+    };
+}
+function comparePatternSpecificity(left, right) {
+    const leftSpecificity = patternSpecificity(left);
+    const rightSpecificity = patternSpecificity(right);
+    return rightSpecificity.staticSegments - leftSpecificity.staticSegments || rightSpecificity.totalSegments - leftSpecificity.totalSegments || leftSpecificity.splatSegments - rightSpecificity.splatSegments || leftSpecificity.dynamicSegments - rightSpecificity.dynamicSegments;
+}
+function sortLocalisedPatterns(patterns) {
+    return patterns.map((pattern, index)=>({
+            pattern,
+            index
+        })).sort((left, right)=>comparePatternSpecificity(left.pattern.pattern, right.pattern.pattern) || left.index - right.index).map(({ pattern })=>pattern);
+}
+function resolveLocalisedPath(pathname, targetLanguage, languages, localisedUrls) {
+    const normalizedPathname = normaliseSlashes(pathname);
+    const canonicalCandidates = sortLocalisedPatterns(Object.entries(localisedUrls || {}).map(([canonicalPattern, localisedUrlEntry])=>({
+            canonicalPattern,
+            localisedUrlEntry,
+            pattern: canonicalPattern
+        })));
+    for (const { canonicalPattern, localisedUrlEntry } of canonicalCandidates){
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        const params = targetPattern ? matchPathPattern(normalizedPathname, canonicalPattern) : null;
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    const localisedCandidates = sortLocalisedPatterns(Object.values(localisedUrls || {}).flatMap((localisedUrlEntry)=>{
+        const targetPattern = localisedUrlEntry[targetLanguage];
+        if (!targetPattern) return [];
+        return languages.map((language)=>localisedUrlEntry[language]).filter(Boolean).map((sourcePattern)=>({
+                pattern: sourcePattern,
+                sourcePattern,
+                targetPattern
+            }));
+    }));
+    for (const { sourcePattern, targetPattern } of localisedCandidates){
+        const params = matchPathPattern(normalizedPathname, sourcePattern);
+        if (params) return buildPathFromPattern(targetPattern, params);
+    }
+    return normalizedPathname;
+}
+function localiseTargetPathname(pathname, language, languages, localisedUrls) {
+    const pathWithoutLanguage = stripLanguagePrefix(pathname, languages);
+    const resolvedPath = localisedUrls ? resolveLocalisedPath(pathWithoutLanguage, language, languages, localisedUrls) : pathWithoutLanguage;
+    const resolvedSegments = resolvedPath.split('/').filter(Boolean);
+    return `/${[
+        language,
+        ...resolvedSegments
+    ].join('/')}`;
+}
+function shouldIgnoreLocaleRedirect(pathname, route, entry) {
+    const remainingPathname = getRouteRemainingPathname(route, pathname);
+    const normalizedPathname = remainingPathname.startsWith('/') ? remainingPathname : `/${remainingPathname}`;
+    const ignoredPrefixes = [
+        ...entry.ignoreRedirectRoutes || [],
+        ...entry.staticRoutePrefixes || [],
+        '/static',
+        '/upload'
+    ];
+    return ignoredPrefixes.some((prefix)=>{
+        const normalizedPrefix = normaliseSlashes(prefix);
+        return normalizedPathname === normalizedPrefix || normalizedPathname.startsWith(`${normalizedPrefix}/`);
+    });
+}
+function buildLocalizedUrl(route, request, language, entry) {
+    const url = new URL(request.url);
+    const basePath = getRouteBasePath(route);
+    const remainingPathname = getRouteRemainingPathname(route, url.pathname);
+    const localizedPathname = localiseTargetPathname(remainingPathname, language, entry.languages, entry.localisedUrls);
+    const nextPathname = '/' === basePath ? localizedPathname : normaliseSlashes(`${basePath}/${localizedPathname}`);
+    return `${nextPathname}${url.search}`;
+}
+function createLocaleRedirectResponse(location, entry) {
+    const headers = new Headers({
+        'cache-control': 'private, no-store',
+        location
+    });
+    const vary = [];
+    const detectionOrder = entry.i18nextDetector ? entry.detection?.order || [] : [];
+    if (detectionOrder.includes('header')) vary.push('Accept-Language');
+    if (detectionOrder.includes('cookie')) vary.push('Cookie');
+    if (vary.length > 0) headers.set('vary', vary.join(', '));
+    return new Response(null, {
+        headers,
+        status: 302
+    });
+}
+function createLocaleRedirectResponseForRequest(route, request) {
+    const entry = getRouteI18nEntry(route);
+    if (!entry || !Array.isArray(entry.languages) || 0 === entry.languages.length) return null;
+    const { pathname, search } = new URL(request.url);
+    if (isAssetLikePathname(pathname)) return null;
+    if (shouldIgnoreLocaleRedirect(pathname, route, entry)) return null;
+    const language = getLanguageFromPath(route, pathname, entry.languages);
+    if (!language) {
+        const targetLanguage = detectRedirectLanguage(request, entry) || entry.fallbackLanguage;
+        return createLocaleRedirectResponse(buildLocalizedUrl(route, request, targetLanguage, entry), entry);
+    }
+    if (entry.localisedUrls) {
+        const expectedUrl = buildLocalizedUrl(route, request, language, entry);
+        if (expectedUrl !== `${pathname}${search}`) return createLocaleRedirectResponse(expectedUrl, entry);
+    }
+    return null;
+}
 function findRoute(request) {
     const { pathname } = new URL(request.url);
     const routes = MODERN_WORKER_MANIFEST.routeSpec.routes;
@@ -399,21 +648,40 @@ async function collectRenderedRemoteCssHrefs(html, request, env) {
 function escapeAttribute(value) {
     return String(value).replace(/&/g, '&amp;').replace(/"/g, '&quot;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
 }
+function isAbsoluteUrl(value) {
+    return /^[a-z][a-z\d+.-]*:/iu.test(value);
+}
+function toRouteCssHtmlHref(asset) {
+    if (isAbsoluteUrl(asset) || asset.startsWith('/')) return asset;
+    return `/${asset.replace(/^\/+/u, '')}`;
+}
 async function withRouteCssLinks(response, route, routeManifest, request, env) {
     const contentType = response.headers.get('content-type') || '';
     if (!contentType.includes('text/html')) return response;
     const html = await response.text();
-    const cssHrefs = [
-        ...collectRouteCssAssets(route, routeManifest).map((asset)=>new URL(asset, request.url).toString()),
-        ...await collectRenderedRemoteCssHrefs(html, request, env)
-    ];
-    if (0 === cssHrefs.length) return response;
-    const uniqueCssHrefs = [
-        ...new Set(cssHrefs)
+    const cssEntries = [
+        ...collectRouteCssAssets(route, routeManifest).map((asset)=>{
+            const href = toRouteCssHtmlHref(asset);
+            return {
+                href,
+                preloadHref: new URL(href, request.url).toString()
+            };
+        }),
+        ...(await collectRenderedRemoteCssHrefs(html, request, env)).map((href)=>({
+                href,
+                preloadHref: new URL(href, request.url).toString()
+            }))
     ];
+    if (0 === cssEntries.length) return response;
+    const seenCssHrefs = new Set();
+    const uniqueCssEntries = cssEntries.filter((entry)=>{
+        if (seenCssHrefs.has(entry.preloadHref)) return false;
+        seenCssHrefs.add(entry.preloadHref);
+        return true;
+    });
     const headers = new Headers(response.headers);
-    for (const href of uniqueCssHrefs)headers.append('link', `<${href}>; rel=preload; as=style`);
-    const links = uniqueCssHrefs.filter((href)=>!html.includes(href)).map((href)=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
+    for (const { preloadHref } of uniqueCssEntries)headers.append('link', `<${preloadHref}>; rel=preload; as=style`);
+    const links = uniqueCssEntries.filter(({ href, preloadHref })=>!html.includes(href) && !html.includes(preloadHref)).map(({ href })=>`<link rel="stylesheet" href="${escapeAttribute(href)}">`);
     if (0 === links.length || !html.includes('</head>')) return new Response(html, {
         headers,
         status: response.status,
@@ -554,21 +822,27 @@ export default {
     async fetch (request, env, ctx) {
         const corsPreflightResponse = await createCorsPreflightResponse(request, env);
         if (corsPreflightResponse) return finalizeResponseForRequest(corsPreflightResponse, request);
-        const assetResponse = await fetchAsset(request, env);
-        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
         const bffResponse = await dispatchBffRequest(request, env);
         if (bffResponse) return finalizeResponseForRequest(withAppCorsHeaders(bffResponse, request), request);
         const route = findRoute(request);
         const { pathname } = new URL(request.url);
-        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
-            status: 404
-        }), request), request);
+        if (isAssetLikePathname(pathname) && !routeMatchesExactly(route, pathname)) {
+            const assetResponse = await fetchAsset(request, env);
+            if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
+            return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
+                status: 404
+            }), request), request);
+        }
+        const localeRedirectResponse = createLocaleRedirectResponseForRequest(route, request);
+        if (localeRedirectResponse) return finalizeResponseForRequest(withAppCorsHeaders(localeRedirectResponse, request), request);
         if (route?.worker) {
             const renderableRequest = createRenderableRequest(request);
             return finalizeResponseForRequest(withAppCorsHeaders(await dispatchRouteWorker(route, renderableRequest, env, ctx), request), request);
         }
         const htmlResponse = await fetchRouteHtml(route, request, env);
         if (htmlResponse) return finalizeResponseForRequest(htmlResponse, request);
+        const assetResponse = await fetchAsset(request, env);
+        if (assetResponse) return finalizeResponseForRequest(assetResponse, request);
         return finalizeResponseForRequest(withAppCorsHeaders(new Response('Not found', {
             status: 404
         }), request), request);

package/dist/esm-node/plugins/deploy/platforms/cloudflare.mjs

@@ -110,6 +110,102 @@ const DEFAULT_CSP_DIRECTIVES = {
         'blob:'
     ]
 };
+const I18N_SERVER_PLUGIN_NAME = 'plugin-i18n/server';
+const DEFAULT_I18NEXT_DETECTION_OPTIONS = {
+    order: [
+        'querystring',
+        'cookie',
+        'localStorage',
+        'header',
+        'navigator',
+        'htmlTag',
+        'path',
+        'subdomain'
+    ],
+    lookupQuerystring: 'lng',
+    lookupCookie: 'i18next',
+    lookupHeader: 'accept-language'
+};
+const SERVER_SIDE_I18N_DETECTORS = new Set([
+    'querystring',
+    'cookie',
+    'header'
+]);
+const isRecord = (value)=>null !== value && 'object' == typeof value && !Array.isArray(value);
+const toStringArray = (value)=>Array.isArray(value) ? value.filter((entry)=>'string' == typeof entry) : [];
+const getI18nServerPlugin = (appContext)=>appContext.serverPlugins?.find((plugin)=>plugin.name.includes(I18N_SERVER_PLUGIN_NAME));
+const removeLocaleDetectionByEntry = (config)=>{
+    const { localeDetectionByEntry: _localeDetectionByEntry, ...rest } = config;
+    return rest;
+};
+const getEntryLocaleDetection = (entryName, localeDetection)=>{
+    const byEntry = isRecord(localeDetection.localeDetectionByEntry) ? localeDetection.localeDetectionByEntry : void 0;
+    const entryConfig = byEntry?.[entryName];
+    const globalConfig = removeLocaleDetectionByEntry(localeDetection);
+    return isRecord(entryConfig) ? {
+        ...globalConfig,
+        ...entryConfig
+    } : globalConfig;
+};
+const normalizeI18nDetection = (detection)=>{
+    const configured = isRecord(detection) ? detection : {};
+    const rawOrder = Array.isArray(configured.order) ? configured.order : DEFAULT_I18NEXT_DETECTION_OPTIONS.order;
+    const order = rawOrder.filter((entry)=>'string' == typeof entry && SERVER_SIDE_I18N_DETECTORS.has(entry));
+    return {
+        order: order.length > 0 ? order : [
+            'querystring',
+            'cookie',
+            'header'
+        ],
+        lookupQuerystring: 'string' == typeof configured.lookupQuerystring && configured.lookupQuerystring ? configured.lookupQuerystring : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupQuerystring,
+        lookupCookie: 'string' == typeof configured.lookupCookie && configured.lookupCookie ? configured.lookupCookie : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupCookie,
+        lookupHeader: 'string' == typeof configured.lookupHeader && configured.lookupHeader ? configured.lookupHeader : DEFAULT_I18NEXT_DETECTION_OPTIONS.lookupHeader
+    };
+};
+const normalizeLocalisedUrls = (localisedUrls)=>{
+    if (!isRecord(localisedUrls) || 0 === Object.keys(localisedUrls).length) return;
+    const normalized = {};
+    for (const [canonicalPath, languageMap] of Object.entries(localisedUrls)){
+        if (!isRecord(languageMap)) continue;
+        const normalizedLanguageMap = Object.fromEntries(Object.entries(languageMap).filter((entry)=>'string' == typeof entry[1] && entry[1].length > 0));
+        if (Object.keys(normalizedLanguageMap).length > 0) normalized[canonicalPath] = normalizedLanguageMap;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : void 0;
+};
+const normalizeWorkerI18nEntry = (entryName, localeDetection, staticRoutePrefixes)=>{
+    const entryConfig = getEntryLocaleDetection(entryName, localeDetection);
+    const languages = toStringArray(entryConfig.languages);
+    if (true !== entryConfig.localePathRedirect || 0 === languages.length) return;
+    const fallbackLanguage = 'string' == typeof entryConfig.fallbackLanguage && entryConfig.fallbackLanguage ? entryConfig.fallbackLanguage : 'en';
+    const ignoreRedirectRoutes = Array.isArray(entryConfig.ignoreRedirectRoutes) ? toStringArray(entryConfig.ignoreRedirectRoutes) : [];
+    const localisedUrls = normalizeLocalisedUrls(entryConfig.localisedUrls);
+    return {
+        i18nextDetector: false !== entryConfig.i18nextDetector,
+        languages,
+        fallbackLanguage,
+        detection: normalizeI18nDetection(entryConfig.detection),
+        ignoreRedirectRoutes,
+        staticRoutePrefixes,
+        ...localisedUrls ? {
+            localisedUrls
+        } : {}
+    };
+};
+const createI18nWorkerManifest = (routeSpec, appContext)=>{
+    const i18nServerPlugin = getI18nServerPlugin(appContext);
+    const localeDetection = i18nServerPlugin?.options?.localeDetection;
+    if (!isRecord(localeDetection)) return;
+    const staticRoutePrefixes = toStringArray(i18nServerPlugin?.options?.staticRoutePrefixes);
+    const entries = {};
+    for (const route of routeSpec.routes){
+        if ('string' != typeof route.entryName || entries[route.entryName]) continue;
+        const entry = normalizeWorkerI18nEntry(route.entryName, localeDetection, staticRoutePrefixes);
+        if (entry) entries[route.entryName] = entry;
+    }
+    return Object.keys(entries).length > 0 ? {
+        entries
+    } : void 0;
+};
 const getCompatibilityDate = (modernConfig)=>{
     const configuredDate = modernConfig.deploy?.worker?.compatibilityDate?.trim();
     const compatibilityDate = configuredDate || DEFAULT_COMPATIBILITY_DATE;
@@ -340,7 +436,7 @@ const readRouteSpec = async (outputDirectory)=>{
     };
 };
 const createMissingEffectBffWorkerError = (outputDirectory, worker)=>new Error(`Cloudflare Effect API runtime is configured, but the BFF worker bundle is missing: ${node_path.join(outputDirectory, worker)}. ${EFFECT_BFF_CLOUDFLARE_IMPORT_GUIDANCE}`);
-const createWorkerManifest = async (outputDirectory, modernConfig)=>{
+const createWorkerManifest = async (outputDirectory, modernConfig, appContext)=>{
     const routeSpec = await readRouteSpec(outputDirectory);
     const routes = await Promise.all(routeSpec.routes.map(async (route)=>{
         const worker = 'string' == typeof route.worker ? route.worker : void 0;
@@ -386,6 +482,7 @@ const createWorkerManifest = async (outputDirectory, modernConfig)=>{
             routeManifest: ROUTE_MANIFEST_FILE
         },
         security: createCloudflareWorkerSecurityPolicy(modernConfig),
+        i18n: createI18nWorkerManifest(routeSpec, appContext),
         bff: isEffectApi && primaryBffPrefix && effectApiWorkerExists ? {
             runtimeFramework: 'effect',
             prefix: primaryBffPrefix,
@@ -476,7 +573,7 @@ const createCloudflarePreset = ({ appContext, modernConfig })=>{
             await fs.writeJSON(wranglerConfigPath, createWranglerConfig(appDirectory, modernConfig), {
                 spaces: 2
             });
-            await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig), {
+            await fs.writeJSON(workerManifestPath, await createWorkerManifest(outputDirectory, modernConfig, appContext), {
                 spaces: 2
             });
             await fs.writeJSON(node_path.join(outputDirectory, OUTPUT_PACKAGE_FILE), {