primate 0.5.2 → 0.6.2

package/source/client/Context.js

@@ -1,47 +0,0 @@
-import Action from "./Action.js";
-import {routes} from "./exports.js";
-
-export default class Context {
-  constructor(name, session) {
-    this.name = name;
-    this.actions = {};
-    this.used_actions = [];
-    this.session = session;
-  }
-
-  get Class() {
-    return this.constructor;
-  }
-
-  async run(data) {
-    const {namespace, action} = data;
-    const route = `${namespace}/${action}`;
-    const Module = routes?.[namespace]?.[action] ?? Action;
-    this.actions[route] = new Module(action, this.session);
-    const nextaction = this.actions[route];
-    nextaction.enter(data);
-    await this.Class.before(nextaction);
-    nextaction.before();
-    this.action = nextaction;
-  }
-
-  static before(action) {
-    return action;
-  }
-
-  static prepare(action, data) {
-    return data;
-  }
-
-  on(key, event) {
-    this.action[`on${key}`](event);
-  }
-
-  push_action() {
-    this.used_actions.push(this.action);
-  }
-
-  pop_action() {
-    this.action = this.used_actions.pop();
-  }
-}

package/source/client/Element.js

@@ -1,249 +0,0 @@
-const reader = new FileReader();
-const file_listener = event => reader.readAsDataURL(event.target.files[0]);
-
-const replace = (attribute, source) => {
-  if (attribute.includes(".")) {
-    const index = attribute.indexOf(".");
-    const left = attribute.slice(0, index);
-    const rest = attribute.slice(index+1);
-    if (source[left] !== undefined) {
-      return replace(rest, source[left]);
-    }
-  } else {
-    return source[attribute];
-  }
-};
-
-const data_prefix_length = 5;
-const data_regex = /\${([^}]*)}/g;
-const fulfill = (attribute, source) => {
-  if (source === undefined) {
-    return undefined;
-  }
-  let {value} = attribute;
-  const matches = [...value.matchAll(data_regex)];
-  if (matches.length > 0) {
-    for (const match of matches) {
-      const [key] = match;
-      const new_value = replace(match[1], source);
-      value = value.replace(key, new_value);
-    }
-  } else {
-    value = replace(value, source);
-  }
-  return value;
-};
-
-const $selector = Symbol("$selector");
-const $element = Symbol("$element");
-const $action = Symbol("$action");
-
-const proxy_handler = {
-  "get": (target, property, receiver) => {
-    if (property === "element") {
-      return target.element;
-    }
-    if (property === "on" || property === "insert") {
-      return target[property].bind(target);
-    }
-    if (target.element === null) {
-      return () => receiver;
-    }
-
-    return (...args) => target[property] === undefined
-      ? receiver
-      : target[property](...args);
-  },
-};
-
-export default class Element {
-  constructor(selector, action) {
-    this[$action] = action;
-    if (typeof selector === "string") {
-      this.construct_by_selector(selector);
-    } else {
-      this.construct_by_element(selector);
-    }
-    return new Proxy(this, proxy_handler);
-  }
-
-  construct_by_selector(selector) {
-    this[$selector] = selector;
-  }
-
-  construct_by_element(element) {
-    this[$element] = element;
-  }
-
-  static value(element, name) {
-    return element?.attributes.getNamedItem(name)?.value;
-  }
-
-  static evaluate(attribute, source, data) {
-    const element = new this(source);
-    const attribute_name = attribute.name.slice(data_prefix_length);
-    element.resolve(attribute_name)(fulfill(attribute, data), attribute_name);
-  }
-
-  resolve(name) {
-    return (this[name] ?? this.default).bind(this);
-  }
-
-  get element() {
-    return this[$element] ?? document.querySelector(this[$selector]);
-  }
-
-  each(callback) {
-    document.querySelectorAll(this[$selector]).forEach(callback);
-  }
-
-  get(name) {
-    return this.element.getAttribute(name);
-  }
-
-  has(attribute) {
-    return this.element[attribute] !== undefined;
-  }
-
-  show() {
-    return this.class("show");
-  }
-
-  hide() {
-    return this.class("show", false);
-  }
-
-  insert() {
-    const element = document.createElement("div");
-    if (this[$selector].startsWith(".")) {
-      element.className = this[$selector].slice(1);
-    }
-    document.body.append(element);
-    return this;
-  }
-
-  replace(child) {
-    this.element.innerHTML = "";
-    return this.append(child);
-  }
-
-  append(child) {
-    if (child instanceof HTMLElement) {
-      this.element.appendChild(child);
-    } else {
-      this.element.innerHTML += child;
-    }
-    return this;
-  }
-
-  set(name, value) {
-    this.element.setAttribute(name, value);
-    return this;
-  }
-
-  class(classes, set) {
-    classes.split(" ").forEach(name => {
-      this.element.classList.toggle(name, set !== false);
-    });
-    return this;
-  }
-
-  remove() {
-    this.element.remove();
-    return this;
-  }
-
-  remove_attribute(name) {
-    this.element.removeAttribute(name);
-    return this;
-  }
-
-  click() {
-    this.element.click();
-    return this;
-  }
-
-  on(event, handler) {
-    this[$action].on(this[$selector], event, handler);
-    return this;
-  }
-
-  defined(value) {
-    return value === undefined && this.remove();
-  }
-
-  html(value) {
-    if (value !== undefined) {
-      this.element.innerHTML = value;
-    }
-    return this;
-  }
-
-  options(value) {
-    value instanceof Array && value.forEach(option => {
-      const children = [...this.element.children];
-      if (!children.find(child => child.value === option._id)) {
-        const newElement = document.createElement("option");
-        newElement.setAttribute("value", option._id);
-        newElement.innerHTML = option.name;
-        this.append(newElement);
-      }
-    });
-  }
-
-  if(value) {
-    return value !== true && this.remove();
-  }
-
-  value(value) {
-    const name = `${this.element.localName}_value`;
-    this[name]?.(value) ?? this.default_value(value);
-  }
-
-  select_value(value) {
-    this.element.value = value === undefined ? "" : value;
-    return this;
-  }
-
-  input_value(value) {
-    const type = Element.value(this.element, "type");
-    this[`input_${type}_value`]?.(value) ?? this.input_input_value(value);
-    return this;
-  }
-
-  textarea_value(value) {
-    return this.input_value(value);
-  }
-
-  input_checkbox_value(value) {
-    if (value === true) {
-      this.element.checked = true;
-    }
-    return this;
-  }
-
-  input_file_value(value) {
-    const {element} = this;
-    if (value !== undefined) {
-      element.setAttribute("base64", value);
-    }
-    reader.onload = ({target}) => element.setAttribute("base64", target.result);
-    element.addEventListener("change", file_listener);
-    return this;
-  }
-
-  input_input_value(value) {
-    if (value !== undefined) {
-      this.element.value = value;
-    }
-    return this;
-  }
-
-  default_value(value) {
-    this.element.innerText = value ?? "";
-  }
-
-  default(value, attribute) {
-    value !== undefined && this.element.setAttribute(attribute, value);
-  }
-}

package/source/client/Node.js

@@ -1,13 +0,0 @@
-export default class Node {
-  constructor(node) {
-    this.node = node;
-  }
-
-  get attributes() {
-    return [...this.node.attributes];
-  }
-
-  get children() {
-    return [...this.node.children];
-  }
-}

package/source/client/Session.js

@@ -1,27 +0,0 @@
-import Context from "./Context.js";
-import {contexts} from "./exports.js";
-
-export default class Session {
-  constructor(client) {
-    this.client = client;
-  }
-
-  async run(data) {
-    const {context} = data;
-    this.context = new (contexts[context] ?? Context)(context, this);
-
-    await this.context.run(data);
-  }
-
-  on(key, event) {
-    this.context.on(key, event);
-  }
-
-  read(pathname) {
-    return this.client.read(pathname);
-  }
-
-  write(pathname, payload) {
-    return this.client.write(pathname, payload);
-  }
-}

package/source/client/View.js

@@ -1,89 +0,0 @@
-// We do not import Element directly from "./Element.js", rather the otherwise
-// preset user version of it, to allow for the user overriding attributes.
-import Element from "../Element.js";
-import Node from "./Node.js";
-
-export default class View {
-  constructor(data, action, root) {
-    this.sources = {};
-    this.store = data.payload;
-    this.action = action;
-    this.paint_into(data, root);
-  }
-
-  paint_into(data, root = document.body) {
-    root.innerHTML = data.view;
-    root.classList.add(data.context);
-    this.unfold(root);
-    if (root === document.body) {
-      window.scrollTo(0, 0);
-    }
-  }
-
-  unfold(node) {
-    this.expand_attributes(new Node(node));
-    new Node(node).children.forEach(child => this.unfold(child));
-  }
-
-  expand_attributes(node) {
-    node.attributes.filter(attribute => attribute.name === "data-scope")
-      .map(attribute => attribute.value)
-      .forEach(scope => this.expand(node.node, this.store[scope], scope));
-  }
-
-  expand(node, data, name, from_update) {
-    if (data instanceof Array) {
-      if (from_update) {
-        return;
-      }
-      const blueprint = document.createElement("div");
-      while (node.children.length > 0) {
-        blueprint.appendChild(node.firstChild);
-      }
-      for (const datum of data) {
-        const element = blueprint.cloneNode(true);
-        this.sources[`${name}-${datum._id}`] = element;
-        node.appendChild(element);
-        this.populate(element, datum, `${name}-${datum._id}`);
-      }
-    } else {
-      this.sources[name] = node;
-      if (data !== undefined) {
-        this.populate(node, data, name);
-      }
-    }
-  }
-
-  populate(node, data, key, from_update) {
-    const regex = /^data-/u;
-    new Node(node).children.forEach(child => {
-      let populate = true;
-      for (let i = 0; i < child.attributes.length; i++) {
-        const attribute = child.attributes[i];
-        const {name, value} = attribute;
-        if (regex.test(name)) {
-          if (name === "data-scope") {
-            this.expand(child, data[value], `${key}-${value}`, from_update);
-            populate = false;
-          } else {
-            Element.evaluate(attribute, child, data);
-          }
-        }
-      }
-      child.children.length !== 0 && populate &&
-        this.populate(child, data, key, from_update);
-    });
-  }
-
-  update(data) {
-    Object.keys(data).forEach(key =>
-      this.sources[key] !== undefined &&
-      this.populate(this.sources[key], data[key], key, true)
-    );
-  }
-
-  write(pathname, payload) {
-    return this.action.write(pathname, payload);
-  }
-
-}

package/source/client/document.js

@@ -1,6 +0,0 @@
-const {baseURI} = document;
-const {host, href, origin} = document.location;
-const base = baseURI === href ? "/" : baseURI.replace(origin, "");
-const origin_base = `${origin}${base}`;
-
-export {base, origin, origin_base, host};

package/source/client/exports.js

@@ -1,15 +0,0 @@
-const timeout = (callback, delay = 0) => new Promise(resolve =>
-  window.setTimeout(() => resolve(callback()), delay));
-
-// This comes first, as Action > View > ../Element.js for user overrideability.
-export {default as Element} from "./Element.js";
-export {default as Action} from "./Action.js";
-export {default as Context} from "./Context.js";
-export {contexts, routes} from "../exports.js";
-export {timeout};
-
-import App from "./App.js";
-
-const app = new App();
-
-export {app};

package/source/preset/client/Element.js

@@ -1,2 +0,0 @@
-import {Element} from "./primate/exports.js";
-export default class extends Element {}

package/source/preset/client/app.js

@@ -1,2 +0,0 @@
-import {app} from "./primate/exports.js";
-app.run();

package/source/server/Action.js

@@ -1,100 +0,0 @@
-import {resolve} from "path";
-import {default as EagerPromise, eager} from "./EagerPromise.js";
-import View from "./view/View.js";
-import Projector from "./Projector.js";
-import {InternalServerError} from "./errors.js";
-import {assert, defined} from "./invariants.js";
-import sanitize from "./sanitize.js";
-
-export default class Action {
-  static action = "index";
-  static namespace = "default";
-  static layout = "default";
-
-  constructor(request, session, context) {
-    this.request = request;
-    this.session = session;
-    this.context = EagerPromise.resolve(context);
-  }
-
-  static async new(request, session, context) {
-    const {namespace = this.namespace, action = this.action} = request.path;
-    assert(!namespace.includes("."), () => {
-      throw new InternalServerError("namespace may not include a dot");
-    });
-    const route = `${namespace}/${action}`;
-    const path = resolve(`${context.directory}/${route}.js`);
-    try {
-      const {"default": UserAction} = await import(path);
-      return new UserAction(request, session, context);
-    } catch (error) {
-      throw new Error(`route \`${route}\` missing`);
-    }
-  }
-
-  get Class() {
-    return this.constructor;
-  }
-
-  get layout() {
-    return this.Class.layout;
-  }
-
-  get path() {
-    const {path} = this.request;
-    const namespace = path.namespace ?? this.Class.namespace;
-    const action = path.action ?? this.Class.action;
-    const {_id} = path;
-    return {action, namespace, _id};
-  }
-
-  get params() {
-    return this.request.params;
-  }
-
-  async run(type) {
-    defined(this[type]);
-    this.before && await this.before();
-    await this[type](sanitize(this.request.payload));
-  }
-
-  return(payload = {}) {
-    this.respond("return", () => ({payload}));
-  }
-
-  view(data = {}, layout = true) {
-    this.respond("view", async () => {
-      const {_view, payload} = await this.prepare(data);
-      const view = layout ? _view.file(this.layout) : _view.content;
-      return {view, payload};
-    });
-  }
-
-  update(data) {
-    this.respond("update", async () =>
-      ({"payload": (await this.prepare(data)).payload})
-    );
-  }
-
-  redirect(location) {
-    this.respond("redirect", () => ({location}));
-  }
-
-  async prepare(data = {}) {
-    const route = `${this.path.namespace}/${this.path.action}`;
-    const path = await eager`${this.context.directory}/${route}`;
-    const _view = await View.new(path, await this.context.layouts);
-    await this.context.Class.prepare(this, data);
-    const payload = await new Projector(data,
-      await _view.elements(this.layout)).project(route);
-    return {payload, _view};
-  }
-
-  respond(type, how) {
-    this.response = async () => {
-      const context = await this.context.name;
-      const {url} = this.request;
-      return {...await how(), type, context, ...this.path, url};
-    };
-  }
-}

package/source/server/App.js

@@ -1,62 +0,0 @@
-import {resolve} from "path";
-import Bundler from "./Bundler.js";
-import File from "./File.js";
-import Router from "./Router.js";
-import DynamicServer from "./servers/Dynamic.js";
-import StaticServer from "./servers/Static.js";
-import cache from "./cache.js";
-import log from "./log.js";
-import package_json from "../../package.json" assert {"type": "json"};
-
-export default class App {
-  constructor(conf) {
-    this.conf = conf;
-    this.Bundler = Bundler;
-  }
-
-  get routes() {
-    return cache(this, "routes", async () => {
-      try {
-        const path = `${this.conf.root}/routes.json`;
-        return (await import(path, {"assert": {"type": "json"}})).default;
-      } catch (error) {
-        // local routes.json not required
-        return [];
-      }
-    });
-  }
-
-  async run() {
-    log.reset("Primate").yellow(package_json.version);
-
-    this.router = new Router(await this.routes, this.conf);
-    const {index, hashes} = await new this.Bundler(this.conf).bundle();
-    const {router} = this;
-
-    const conf = {index, hashes, router,
-      "serve_from": this.conf.paths.public,
-      "http": {
-        ...this.conf.http,
-        "key": File.read_sync(resolve(this.conf.http.ssl.key)),
-        "cert": File.read_sync(resolve(this.conf.http.ssl.cert)),
-      },
-      "context": this.conf.defaults.context,
-    };
-    this.static_server = new StaticServer(conf);
-    await this.static_server.run();
-
-    this.dynamic_server = new DynamicServer({router,
-      "path": this.conf.base,
-      "server": this.static_server.server,
-      "context": this.conf.defaults.context,
-    });
-    await this.dynamic_server.run();
-
-    const {port, host} = this.conf.http;
-    this.static_server.listen(port, host);
-  }
-
-  stop() {
-    this.static_server.close();
-  }
-}