Initial Commit of new version

Author: harmony7

package-lock.json

@@ -1,7 +1,7 @@
 {
   "name": "@fastly/compute-js-static-publish",
   "type": "module",
-  "version": "3.6.0",
+  "version": "4.0.0-alpha.0",
   "description": "Static Publisher for Compute@Edge JavaScript",
   "main": "./build/index.js",
   "types": "./build/index.d.ts",

package.json

@@ -1,35 +1,35 @@
 const defaultContentTypes = [
   // Text formats
-  { test: /.txt$/, type: 'text/plain', binary: false },
-  { test: /.htm(l)?$/, type: 'text/html', binary: false },
-  { test: /.xml$/, type: 'application/xml', binary: false },
-  { test: /.json$/, type: 'application/json', binary: false },
-  { test: /.map$/, type: 'application/json', binary: false },
-  { test: /.js$/, type: 'application/javascript', binary: false },
-  { test: /.css$/, type: 'text/css', binary: false },
-  { test: /.svg$/, type: 'image/svg+xml', binary: false },
+  { test: /.txt$/, contentType: 'text/plain', text: true },
+  { test: /.htm(l)?$/, contentType: 'text/html', text: true },
+  { test: /.xml$/, contentType: 'application/xml', text: true },
+  { test: /.json$/, contentType: 'application/json', text: true },
+  { test: /.map$/, contentType: 'application/json', text: true },
+  { test: /.js$/, contentType: 'application/javascript', text: true },
+  { test: /.css$/, contentType: 'text/css', text: true },
+  { test: /.svg$/, contentType: 'image/svg+xml', text: true },
 
   // Binary formats
-  { test: /.bmp$/, type: 'image/bmp', binary: true },
-  { test: /.png$/, type: 'image/png', binary: true },
-  { test: /.gif$/, type: 'image/gif', binary: true },
-  { test: /.jp(e)?g$/, type: 'image/jpeg', binary: true },
-  { test: /.ico$/, type: 'image/vnd.microsoft.icon', binary: true },
-  { test: /.tif(f)?$/, type: 'image/png', binary: true },
-  { test: /.aac$/, type: 'audio/aac', binary: true },
-  { test: /.mp3$/, type: 'audio/mpeg', binary: true },
-  { test: /.avi$/, type: 'video/x-msvideo', binary: true },
-  { test: /.mp4$/, type: 'video/mp4', binary: true },
-  { test: /.mpeg$/, type: 'video/mpeg', binary: true },
-  { test: /.webm$/, type: 'video/webm', binary: true },
-  { test: /.pdf$/, type: 'application/pdf', binary: true },
-  { test: /.tar$/, type: 'application/x-tar', binary: true },
-  { test: /.zip$/, type: 'application/zip', binary: true },
-  { test: /.eot$/, type: 'application/vnd.ms-fontobject', binary: true },
-  { test: /.otf$/, type: 'font/otf', binary: true },
-  { test: /.ttf$/, type: 'font/ttf', binary: true },
-  { test: /.woff$/, type: 'font/woff', binary: true },
-  { test: /.woff2$/, type: 'font/woff2', binary: true },
+  { test: /.bmp$/, contentType: 'image/bmp', text: false },
+  { test: /.png$/, contentType: 'image/png', text: false },
+  { test: /.gif$/, contentType: 'image/gif', text: false },
+  { test: /.jp(e)?g$/, contentType: 'image/jpeg', text: false },
+  { test: /.ico$/, contentType: 'image/vnd.microsoft.icon', text: false },
+  { test: /.tif(f)?$/, contentType: 'image/png', text: false },
+  { test: /.aac$/, contentType: 'audio/aac', text: false },
+  { test: /.mp3$/, contentType: 'audio/mpeg', text: false },
+  { test: /.avi$/, contentType: 'video/x-msvideo', text: false },
+  { test: /.mp4$/, contentType: 'video/mp4', text: false },
+  { test: /.mpeg$/, contentType: 'video/mpeg', text: false },
+  { test: /.webm$/, contentType: 'video/webm', text: false },
+  { test: /.pdf$/, contentType: 'application/pdf', text: false },
+  { test: /.tar$/, contentType: 'application/x-tar', text: false },
+  { test: /.zip$/, contentType: 'application/zip', text: false },
+  { test: /.eot$/, contentType: 'application/vnd.ms-fontobject', text: false },
+  { test: /.otf$/, contentType: 'font/otf', text: false },
+  { test: /.ttf$/, contentType: 'font/ttf', text: false },
+  { test: /.woff$/, contentType: 'font/woff', text: false },
+  { test: /.woff2$/, contentType: 'font/woff2', text: false },
 ];
 
 function mergeContentTypes(contentTypes) {
@@ -51,23 +51,23 @@ function mergeContentTypes(contentTypes) {
         invalid = true;
       }
 
-      if(typeof contentType.type !== 'string' || contentType.type.indexOf('/') === -1) {
+      if(typeof contentType.contentType !== 'string' || contentType.contentType.indexOf('/') === -1) {
         console.log(`⚠️ Ignoring contentTypes[${index}]: 'type' must be a string representing a MIME type.`);
         invalid = true;
       }
 
-      if('binary' in contentType && typeof contentType.binary !== 'boolean') {
-        console.log(`⚠️ Ignoring contentTypes[${index}]: optional 'binary' must be a boolean value.`);
+      if('text' in contentType && typeof contentType.text !== 'boolean') {
+        console.log(`⚠️ Ignoring contentTypes[${index}]: optional 'text' must be a boolean value.`);
         invalid = true;
       }
 
       if(!invalid) {
         const contentTypeDef = {
           test: contentType.test,
-          type: contentType.type,
+          contentType: contentType.contentType,
         };
-        if(contentType.binary != null) {
-          contentTypeDef.binary = contentType.binary;
+        if(contentType.text != null) {
+          contentTypeDef.text = contentType.text;
         }
         finalContentTypes.push(contentTypeDef);
       }
@@ -83,17 +83,17 @@ function mergeContentTypes(contentTypes) {
   return finalContentTypes;
 }
 
-function testFileContentType(contentTypes, file) {
+function testFileContentType(contentTypes, assetKey) {
   for (const contentType of contentTypes ?? defaultContentTypes) {
     let matched = false;
     if(contentType.test instanceof RegExp) {
-      matched = contentType.test.test(file);
+      matched = contentType.test.test(assetKey);
     } else {
       // should be a function
-      matched = contentType.test(file);
+      matched = contentType.test(assetKey);
     }
     if(matched) {
-      return { type: contentType.type, binary: Boolean(contentType.binary) };
+      return { contentType: contentType.contentType, text: Boolean(contentType.text ?? false) };
     }
   }
   return null;

resources/default-content-types.cjs

@@ -1,15 +1,10 @@
-export type ContentTypeDef = {
-  test: RegExp | ((path: string) => boolean),
-  type: string,
-  binary?: boolean,
-};
+// Content Type test
 
-export type ContentTypeTestResult = {
-  type: string,
-  binary: boolean,
-};
+import {
+  ContentTypeDef,
+  ContentTypeTestResult,
+} from '@fastly/compute-js-static-publish';
 
 declare const defaultContentTypes: ContentTypeDef[];
-
 declare function mergeContentTypes(entries?: ContentTypeDef[]): ContentTypeDef[];
-declare function testFileContentType(entries: ContentTypeDef[] | null | undefined, path: string): ContentTypeTestResult | null;
+declare function testFileContentType(entries: ContentTypeDef[] | null | undefined, assetKey: string): ContentTypeTestResult | null;

resources/default-content-types.d.ts

@@ -1,122 +1,16 @@
 /// <reference types="@fastly/js-compute" />
 
-import { Router } from '@fastly/expressly';
-import { staticAssets, spaFile, notFoundPageFile, autoIndex, autoExt } from './statics';
+import { getServer } from './statics.js';
 
-const router = new Router();
+addEventListener("fetch", (event) => event.respondWith(handleRequest(event)));
+async function handleRequest(event) {
 
-function getMatchingRequestPath(path) {
+  const server = getServer();
+  const response = await server.serveRequest(event.request);
 
-  if(!path.endsWith('/')) {
-    // A path that does not end in a slash can match an asset directly
-    if (staticAssets.getAsset(path) != null) {
-      return path;
-    }
-
-    // ... or, we can try auto-ext:
-    // looks for an asset that has the specified suffix (usually extension, such as .html)
-    if(Array.isArray(autoExt)) {
-      for (const extEntry of autoExt) {
-        let pathWithExt = path + extEntry;
-        if (staticAssets.getAsset(pathWithExt) != null) {
-          return pathWithExt;
-        }
-      }
-    }
-  }
-
-  // try auto-index:
-  // treats the path as a directory, and looks for an asset with the specified
-  // suffix (usually an index file, such as index.html)
-  let dir = path;
-  // remove all slashes from end, and add one trailing slash
-  while(dir.endsWith('/')) {
-    dir = dir.slice(0, -1);
+  if (response != null) {
+    return response;
   }
-  dir = dir + '/';
-  if(Array.isArray(autoIndex)) {
-    for (const indexEntry of autoIndex) {
-      let indexPath = dir + indexEntry;
-      if (staticAssets.getAsset(indexPath) != null) {
-        return indexPath;
-      }
-    }
-  }
-
-  return null;
-}
 
-function requestAcceptsTextHtml(req) {
-  const accept = (req.headers.get('Accept') ?? '')
-    .split(',')
-    .map(x => x.split(';')[0]);
-  if(!accept.includes('text/html') && !accept.includes('*/*') && accept.includes('*')) {
-    return false;
-  }
-  return true;
+  return new Response('Not found', { status: 404 });
 }
-
-router.get("*", (req, res) => {
-  const assetPath = getMatchingRequestPath(req.urlObj.pathname);
-  const asset = staticAssets.getAsset(assetPath);
-  if(asset == null) {
-    return;
-  }
-
-  const response = staticAssets.serveAsset(asset);
-  res.send(response);
-});
-
-// TODO: If you need to handle any API routes, add them here.
-// router.get("/api/endpoint", (req, res) => {
-//   res.send("foo");
-// });
-
-// If this is a SPA, then return index.html for HTML requests
-router.get("*", (req, res) => {
-  if(!spaFile) {
-    return;
-  }
-  if(!requestAcceptsTextHtml(req)) {
-    return;
-  }
-  const asset = staticAssets.getAsset(spaFile);
-  if(asset == null) {
-    return;
-  }
-
-  const response = new Response(asset.content, {
-    status: 200,
-    headers: {
-      'Cache-Control': 'no-cache',
-      'Content-Type': 'text/html',
-    }
-  });
-  res.send(response);
-});
-
-router.all("*", (req, res) => {
-  if(notFoundPageFile && requestAcceptsTextHtml(req)) {
-    const asset = staticAssets.getAsset(notFoundPageFile);
-    if(asset != null) {
-      const response = new Response(asset.content, {
-        status: 404,
-        headers: {
-          'Cache-Control': 'no-cache',
-          'Content-Type': 'text/html',
-        }
-      });
-      res.send(response);
-      return;
-    }
-  }
-
-  res.send(new Response("404 Not Found", {
-    status: 404,
-    headers: {
-      'Content-Type': 'text/plain',
-    },
-  }));
-});
-
-router.listen();

resources/index.js

@@ -0,0 +1,10 @@
+/*
+ * Generated by @fastly/compute-js-static-publish.
+ */
+
+import type {
+  ContentAssetMetadataMap,
+} from "@fastly/compute-js-static-publish";
+
+export declare const objectStoreName: string | null;
+export declare const contentAssetMetadataMap: ContentAssetMetadataMap;

resources/statics-metadata.d.ts

@@ -2,10 +2,18 @@
  * Generated by @fastly/compute-js-static-publish.
  */
 
-import type { AssetsMap, StaticAssets } from "@fastly/compute-js-static-publish";
-export declare const assets: AssetsMap;
-export declare const spaFile: string | false;
-export declare const notFoundPageFile: string | false;
-export declare const autoIndex: string[] | false;
-export declare const autoExt: string[] | false;
-export declare const staticAssets: StaticAssets;
+import type {
+  ModuleAssetMap,
+  PublisherServerConfigNormalized,
+  ContentAssets,
+  ModuleAssets,
+  PublisherServer,
+} from '@fastly/compute-js-static-publish';
+
+export declare const moduleAssetMap: ModuleAssetMap;
+
+export declare const serverConfig: PublisherServerConfigNormalized;
+export declare const contentAssets: ContentAssets;
+export declare const moduleAssets: ModuleAssets;
+
+export declare function getServer(): PublisherServer;

resources/statics.d.ts

@@ -0,0 +1,17 @@
+export abstract class AssetManager<TAsset> {
+
+  protected readonly assets: Record<string, TAsset>;
+
+  protected constructor() {
+    this.assets = {};
+  }
+
+  setAsset(assetKey: string, asset: TAsset) {
+    this.assets[assetKey] = asset;
+  }
+
+  getAsset(assetKey: string): TAsset | null {
+    return this.assets[assetKey] ?? null;
+  }
+
+}