Implement fallback capability (#44)

* Implement fallback capability

This makes it possible for a dynamic component to render fallback content on the server.

The mechanism is a special `static` prop passed to the component. If `static` is true then the component knows it can render static content.

Putting aside the word `static`, is this the right approach? I think giving components the flexibility to make the decision themselves *is* the right approach.

However in this case we have a special property that is passed in non-explicitly. I think we have to do it this way because if the caller passes in a prop it will get serialized and appear on the client. By making this something we *add* during rendering, it only happens on the server (and only when using `:load`).

Assuming this is the right approach, is `static` the right name for this prop? Other candidates:

* `server`

That's all I have!

* Use `import.meta.env.astro` to tell if running in SSR mode.

* Run formatter

1 files changed, 33 insertions, 0 deletions

diff --git a/test/helpers.js b/test/helpers.js
new file mode 100644
index 000000000..c913ef912
--- /dev/null
+++ b/test/helpers.js
@@ -0,0 +1,33 @@
+import { createRuntime } from '../lib/runtime.js';
+import { loadConfig } from '../lib/config.js';
+import * as assert from 'uvu/assert';
+
+export function setup(Suite, fixturePath) {
+  let runtime, setupError;
+
+  Suite.before(async (context) => {
+    const astroConfig = await loadConfig(new URL(fixturePath, import.meta.url).pathname);
+
+    const logging = {
+      level: 'error',
+      dest: process.stderr,
+    };
+
+    try {
+      runtime = await createRuntime(astroConfig, { logging });
+    } catch (err) {
+      console.error(err);
+      setupError = err;
+    }
+
+    context.runtime = runtime;
+  });
+
+  Suite.after(async () => {
+    (await runtime) && runtime.shutdown();
+  });
+
+  Suite('No errors creating a runtime', () => {
+    assert.equal(setupError, undefined);
+  });
+}