File Coverage

blib/lib/Mojolicious/Plugin/WebComponent.pm

Criterion	Covered	Total	%
statement	87	96	90.6
branch	20	34	58.8
condition	6	15	40.0
subroutine	9	9	100.0
pod	1	1	100.0
total	123	155	79.3

package Mojolicious::Plugin::WebComponent;
use v5.20;
use Mojo::Base 'Mojolicious::Plugin', -signatures;
use Carp;
use Data::Dumper;

our $VERSION = "0.07";

has route => sub {
    my $self = shift;
    my $root = $self->config->{path} ? $self->config->{path} : '/component';
    $self->app->routes->any([ qw(HEAD GET) ] => "$root/:req/*component")->name('webcomponent')->to(cb => \&_serve);
};
has 'app';
has 'config';

sub register($self, $app, $config) {
    $self->config($config);
    $self->app($app);

    my $helper = 'component';

    if ($app->renderer->helpers->{$helper}) {
        return $app->log->debug("WebComponent: Helper $helper() is already registered.");
    }

    $app->defaults('webcomponent.helper' => $helper);

    $app->helper($helper => sub {@_ == 1 ? $self : $self->_component(@_)});
}

sub _serve {
    my $c = shift;
    my $helper = $c->stash('webcomponent.helper');
    my $self = $c->$helper;
    my $app = $self->app;

    my $component = $c->param('component');
    my $params = $self->_getAllParams($c)->to_hash;

    my $assetDir = $app->static->asset_dir;
    my $javascriptPath = $self->config->{javascript_path} ? $self->config->{javascript_path} : "components";
    my $templatePath = $self->config->{template_path} ? $self->config->{template_path} : "components";

    my $templateFile;
    my $skipTemplate;
    if (exists($params->{template})) {
        my $template = $params->{template};
        if ($template =~ m/(false|f|no|0)/i || !defined($template)) {
            $skipTemplate = 1;
        }
        else {
            $templateFile = $template;
        }
    }

    my $tmpl;
    if (!defined($skipTemplate)) {
        my $tmplHtml;
        # if the template file is not set,
        $templateFile //= $component =~ s/\.js//gr;
        my $template = "$templatePath/$templateFile";
        if ($app->renderer->{templates}->{"$template.html"}) {
            $tmplHtml = $c->render_to_string($template, params => $params);
        }

        # If the template file was not found, show it
        $tmplHtml //= "404 -  $template template not found";

        $tmpl = qq{
                    let tmpl = document.createElement('template');
                    tmpl.innerHTML = `$tmplHtml`
            };
    }

    # my $publicPath = $app->static->{paths}->[0];
    my $js = "/$assetDir/js/$javascriptPath/$component";
    my $asset = $app->static->file($js);

    my $content;
    my $fh = $asset->handle;
    my $tmplInit = 0;
    while (<$fh>) {
        if ($tmpl && !$tmplInit) {
            if ($_ =~ m/let tmpl;/) {
                $content .= $tmpl;
                $tmplInit = 1;
                next;
            }
            if ($_ =~ m/shadowRoot.appendChild\(tmpl.content.cloneNode\(true\)\)/) {
                $content .= $tmpl;
                $tmplInit = 1;
            }
        }

        $content .= $_;
    }

    $c->render(text => $content);
}

sub _component {
    my $self = shift;
    my $c = shift;
    my $name = shift;
    my $opts = shift;
    my $route = $self->route;

    my $base = $c->req->url->base->path->{path};
    my $path = $base ? $base . $route->pattern->unparsed
        : $route->pattern->unparsed;

    if (exists($opts->{template})) {
        my $template = defined($opts->{template}) ? $opts->{template} : 'false';
        $c->req->params->merge(template => $template);
    }

    my $params = $self->_getAllParams($c);
    my $paramString = $params->to_string;
    my $reqId = $opts->{requestId} || $c->req->request_id;

    $name .= ".js" if $name !~ m/\.js$/;

    # :req/:component
    $path =~ s/:req/$reqId/;
    $path =~ s/\*component/$name/;
    $path .= "?$paramString" if length($paramString);
    my $ref = "";

    return Mojo::ByteStream->new($ref)
}

sub _getAllParams($self, $c) {
    my $rp = $c->req->params->to_hash;
    %{$rp} = (%{$rp}, %{$c->stash->{'mojo.captures'}}) if $c->stash->{'mojo.captures'};
    my $params = Mojo::Parameters->new(%{$rp});
    delete $params->{cb}; # remove the callback routine
    return $params;
}

1;
__END__