@barefootjs/mojolicious 0.1.0

package/lib/Mojolicious/Plugin/BarefootJS/DevReload.pm

@@ -0,0 +1,150 @@
+package Mojolicious::Plugin::BarefootJS::DevReload;
+use Mojo::Base 'Mojolicious::Plugin', -signatures;
+
+=head1 NAME
+
+Mojolicious::Plugin::BarefootJS::DevReload - Dev-only browser auto-reload for BarefootJS apps
+
+=head1 SYNOPSIS
+
+    # In your Mojolicious::Lite app (development mode)
+    plugin 'BarefootJS::DevReload';
+
+    # Then in your layout template, before </body>:
+    %== bf_dev_snippet
+
+=head1 DESCRIPTION
+
+Companion to C<barefoot build --watch> in C<@barefootjs/cli>. The CLI drops
+C<< <dist>/.dev/build-id >> after every successful rebuild that changed
+output; this plugin watches that file and streams SSE C<< event: reload >>
+to subscribed browsers so an editor save triggers an automatic reload.
+
+Disabled automatically when C<< $app->mode eq 'production' >> (set via
+C<MOJO_MODE=production>). Pass C<< enabled => 0 >> to disable explicitly or
+C<< enabled => 1 >> to force-enable.
+
+=cut
+
+use Mojo::ByteStream qw(b);
+use Mojo::IOLoop;
+use File::Spec;
+
+# Sentinel path contract with @barefootjs/cli (DEV_SENTINEL_SUBDIR /
+# DEV_SENTINEL_FILENAME in packages/cli/src/lib/build.ts). Duplicated so this
+# package avoids a runtime dep on the CLI — keep in sync with the CLI.
+my $DEV_SUBDIR         = '.dev';
+my $BUILD_ID_FILE      = 'build-id';
+my $SCROLL_STORAGE_KEY = '__bf_devreload_scroll';
+
+# Heartbeat < any reasonable proxy/IOLoop idle timeout so a quiet connection
+# doesn't get reaped between rebuilds.
+my $HEARTBEAT_S = 5;
+
+# Polling instead of Linux::Inotify2 / Mac::FSEvents keeps the runtime
+# dependency-free. Sub-second latency is imperceptible next to browser reload.
+my $POLL_S = 0.5;
+
+sub register ($self, $app, $config = {}) {
+    my $dist_dir = $config->{dist_dir} // 'dist';
+    my $endpoint = $config->{endpoint} // '/_bf/reload';
+    my $enabled  = exists $config->{enabled}
+        ? $config->{enabled}
+        : ($app->mode ne 'production');
+
+    # Snippet helper is always registered so templates don't have to branch
+    # on mode — it simply returns an empty ByteStream when disabled.
+    $app->helper(bf_dev_snippet => sub ($c) {
+        return b('') unless $enabled;
+        return b(_snippet($endpoint));
+    });
+
+    return unless $enabled;
+
+    # Resolve dist_dir relative to the Mojolicious home when not already
+    # absolute, so both `dist_dir => 'dist'` (the common case) and
+    # `dist_dir => '/abs/path'` (tests) work.
+    my $dist_abs = File::Spec->file_name_is_absolute($dist_dir)
+        ? $dist_dir
+        : $app->home->child($dist_dir)->to_string;
+    my $dev_dir       = File::Spec->catdir($dist_abs, $DEV_SUBDIR);
+    my $build_id_path = File::Spec->catfile($dev_dir, $BUILD_ID_FILE);
+    mkdir $dev_dir unless -d $dev_dir;
+
+    $app->routes->get($endpoint => sub ($c) {
+        my $last_event_id = $c->req->headers->header('Last-Event-ID') // '';
+        $last_event_id =~ s/^\s+|\s+$//g;
+
+        $c->res->headers->content_type('text/event-stream');
+        $c->res->headers->cache_control('no-cache, no-transform');
+        $c->res->headers->connection('keep-alive');
+        $c->res->headers->header('X-Accel-Buffering' => 'no');
+
+        $c->write("retry: 1000\n\n");
+
+        my $initial_id = _read_build_id($build_id_path);
+        my $last_sent  = '';
+        if (length $initial_id) {
+            $last_sent = $initial_id;
+            # When the client reconnects with a stale Last-Event-ID, a build
+            # happened during its disconnected window — fire `reload`
+            # immediately so the missed rebuild does not silently stay
+            # unpainted until the next change.
+            my $event = (length $last_event_id && $last_event_id ne $initial_id)
+                ? 'reload' : 'hello';
+            $c->write("event: $event\nid: $initial_id\ndata: $initial_id\n\n");
+        }
+
+        my ($hb_id, $poll_id);
+        $c->on(finish => sub {
+            Mojo::IOLoop->remove($hb_id)   if $hb_id;
+            Mojo::IOLoop->remove($poll_id) if $poll_id;
+        });
+
+        $hb_id = Mojo::IOLoop->recurring($HEARTBEAT_S => sub {
+            $c->write(": hb\n\n");
+        });
+        $poll_id = Mojo::IOLoop->recurring($POLL_S => sub {
+            my $id = _read_build_id($build_id_path);
+            return unless length $id;
+            return if $id eq $last_sent;
+            $last_sent = $id;
+            $c->write("event: reload\nid: $id\ndata: $id\n\n");
+        });
+    });
+
+    return;
+}
+
+sub _read_build_id ($path) {
+    return '' unless -f $path;
+    open my $fh, '<', $path or return '';
+    local $/;
+    my $content = <$fh>;
+    close $fh;
+    $content //= '';
+    $content =~ s/^\s+|\s+$//g;
+    return $content;
+}
+
+sub _snippet ($endpoint) {
+    my $ep = _js_str($endpoint);
+    my $sk = _js_str($SCROLL_STORAGE_KEY);
+    # Small IIFE: EventSource subscriber + scrollY preservation. Idempotent
+    # across duplicate mounts (window.__bfDevReload guard).
+    return qq{<script>(function(){if(window.__bfDevReload)return;window.__bfDevReload=1;try{var s=sessionStorage.getItem($sk);if(s){sessionStorage.removeItem($sk);var y=parseInt(s,10);if(!isNaN(y)){var restore=function(){window.scrollTo(0,y)};if(document.readyState==='loading'){addEventListener('DOMContentLoaded',restore,{once:true})}else{restore()}}}}catch(e){}var es=new EventSource($ep);es.addEventListener('reload',function(){try{sessionStorage.setItem($sk,String(window.scrollY))}catch(e){}location.reload()});es.addEventListener('error',function(){})})();</script>};
+}
+
+sub _js_str ($s) {
+    # Minimal JS string escape for the handful of characters that can appear
+    # in a URL path or storage key. Good enough for package-internal + trusted
+    # operator-supplied strings; never interpolate untrusted input here.
+    my $t = $s;
+    $t =~ s/\\/\\\\/g;
+    $t =~ s/"/\\"/g;
+    $t =~ s/\n/\\n/g;
+    $t =~ s/\r/\\r/g;
+    return qq{"$t"};
+}
+
+1;

package/lib/Mojolicious/Plugin/BarefootJS.pm

@@ -0,0 +1,104 @@
+package Mojolicious::Plugin::BarefootJS;
+use Mojo::Base 'Mojolicious::Plugin', -signatures;
+
+use Mojo::File qw(path);
+use Mojo::JSON qw(decode_json);
+
+use BarefootJS;
+
+# Plugin entry point. Wires up:
+#
+#   1. The `bf` controller helper. Lazily instantiates one
+#      BarefootJS object per request and stashes it under
+#      `bf.instance`.
+#
+#   2. A `before_render` hook that, when the rendered template name
+#      matches a top-level component in the build manifest, fills the
+#      heavy boilerplate the user previously hand-rolled in `app.pl`:
+#      generates the scope id, registers every UI-registry child
+#      renderer from the manifest, and seeds the stash with each
+#      template variable's static default (issue #1416).
+#
+# Configuration (all optional):
+#   - manifest_path: absolute path to the `bf build`-emitted
+#     `manifest.json`. Defaults to `<app->home>/dist/templates/manifest.json`.
+#     Pass `undef` to disable manifest-driven auto-init entirely; the
+#     bf helper is still installed and callers can drive everything
+#     manually as before.
+sub register ($self, $app, $config = {}) {
+    $app->helper(bf => sub ($c) {
+        $c->stash->{'bf.instance'} //= BarefootJS->new($c, $config);
+    });
+
+    my $manifest = _load_manifest($app, $config);
+    return unless $manifest;
+
+    # Cache the set of UI-registry slot keys so we can answer
+    # "is this template name a child or a top-level page?" with a
+    # single hash lookup at render time. Top-level entries are
+    # everything that isn't `__barefoot__` and doesn't match
+    # `ui/<name>/index` — the same partition `register_components_from_manifest`
+    # applies internally.
+    my %is_child_entry;
+    for my $entry_name (keys %$manifest) {
+        next if $entry_name eq '__barefoot__';
+        next unless $entry_name =~ m{^ui/[^/]+/index$};
+        $is_child_entry{$entry_name} = 1;
+    }
+
+    $app->hook(before_render => sub ($c, $args) {
+        my $template = $args->{template};
+        return unless defined $template && length $template;
+        my $entry = $manifest->{$template};
+        return unless $entry;
+        return if $is_child_entry{$template};
+        # Idempotency guard for nested renders. A controller might
+        # call `render_to_string` inside an action and then `render`
+        # — without this we'd re-init `bf` on the second pass and
+        # wipe the script registrations the first pass collected.
+        return if $c->stash->{'bf.auto_init_done'};
+
+        # Escape hatch for callers that wire `bf` up by hand (the
+        # existing `render_component` helper in the showcase app does
+        # this). If `_scope_id` is already set we treat the request as
+        # "manually managed" and leave it alone — same outcome as
+        # before the plugin gained auto-init.
+        my $bf = $c->bf;
+        if (defined $bf->_scope_id && length $bf->_scope_id) {
+            $c->stash->{'bf.auto_init_done'} = 1;
+            return;
+        }
+        $c->stash->{'bf.auto_init_done'} = 1;
+
+        $bf->_scope_id($template . '_' . substr(rand() =~ s/^0\.//r, 0, 6));
+        $bf->register_components_from_manifest($manifest);
+
+        # Seed each ssrDefault into the stash unless the caller has
+        # already supplied a value for that key — callers always win.
+        my $defaults = $entry->{ssrDefaults};
+        if (ref($defaults) eq 'HASH') {
+            for my $name (keys %$defaults) {
+                next if exists $c->stash->{$name};
+                my $d = $defaults->{$name};
+                my $value = ref($d) eq 'HASH' ? $d->{value} : $d;
+                $c->stash->{$name} = $value;
+            }
+        }
+    });
+}
+
+sub _load_manifest ($app, $config) {
+    return undef if exists $config->{manifest_path} && !defined $config->{manifest_path};
+    my $manifest_path = $config->{manifest_path}
+        // $app->home->child('dist/templates/manifest.json');
+    my $file = path($manifest_path);
+    return undef unless -r $file;
+    my $manifest = eval { decode_json($file->slurp) };
+    if ($@ || ref($manifest) ne 'HASH') {
+        $app->log->warn("BarefootJS: cannot parse manifest at $file: $@") if $@;
+        return undef;
+    }
+    return $manifest;
+}
+
+1;

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@barefootjs/mojolicious",
+  "version": "0.1.0",
+  "description": "Mojolicious EP template adapter for BarefootJS - generates .html.ep files from IR",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./adapter": {
+      "types": "./dist/adapter/index.d.ts",
+      "import": "./dist/adapter/index.js"
+    },
+    "./test-render": {
+      "bun": "./src/test-render.ts"
+    },
+    "./build": {
+      "types": "./dist/build.d.ts",
+      "import": "./dist/build.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "lib"
+  ],
+  "scripts": {
+    "build": "bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/index.ts ./src/adapter/index.ts ./src/build.ts --root ./src --outdir ./dist --format esm --external @barefootjs/jsx --external @barefootjs/shared",
+    "build:types": "tsgo --emitDeclarationOnly --outDir ./dist",
+    "test": "bun test",
+    "clean": "rm -rf dist",
+    "prepack": "node ../../scripts/swap-publish-config.mjs pack",
+    "postpack": "node ../../scripts/swap-publish-config.mjs unpack"
+  },
+  "keywords": [
+    "mojolicious",
+    "mojo",
+    "perl",
+    "template",
+    "barefoot",
+    "ssr"
+  ],
+  "author": "kobaken <kentafly88@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/piconic-ai/barefootjs",
+    "directory": "packages/adapter-mojolicious"
+  },
+  "dependencies": {
+    "@barefootjs/shared": "workspace:*"
+  },
+  "peerDependencies": {
+    "@barefootjs/jsx": "workspace:*"
+  },
+  "devDependencies": {
+    "@barefootjs/adapter-tests": "workspace:*",
+    "@barefootjs/jsx": "workspace:*",
+    "typescript": "^5.0.0"
+  }
+}