primate 0.5.0 → 0.6.0

package/source/client/Client.js

@@ -1,61 +0,0 @@
-import Session from "./Session.js";
-import {base, host, origin_base} from "./document.js";
-
-const events = ["submit", "click", "change", "input"];
-let back = undefined;
-const location = `wss://${host}${base}`;
-
-export default class Client {
-  constructor(conf) {
-    this.conf = conf;
-    this.session = new Session(this);
-
-    window.onpopstate = async event => {
-      const {pathname, search} = event.target.location;
-      return this.session.run(await this.read(pathname + search));
-    };
-
-    for (const key of events) {
-      window.addEventListener(key, event => this.session.on(key, event));
-    }
-  }
-
-  open() {
-    return this.connection?.readyState === 1 ? this
-      : new Promise(resolve => {
-        this.connection = new WebSocket(location);
-        this.connection.addEventListener("message", ({data}) => data === "open"
-          ? resolve(this)
-          : this.receive(JSON.parse(data)));
-      });
-  }
-
-  async receive(data) {
-    if (back === undefined) {
-      await this.session.execute(data);
-    } else {
-      back(data);
-      back = undefined;
-    }
-  }
-
-  read(url) {
-    return this.send("read", url);
-  }
-
-  write(url, payload) {
-    return this.send("write", url, payload);
-  }
-
-  async send(type, url, payload = {}) {
-    await this.open();
-    const {pathname, search} = new URL(url, origin_base);
-    const _url = pathname + search;
-    return new Promise(resolve => {
-      back = data => resolve(data);
-      this.connection.send(JSON.stringify({
-        type, pathname, search, payload, "url": _url,
-      }));
-    });
-  }
-}

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/preset/data/stores/default.js

@@ -1,2 +0,0 @@
-import MemoryStore from "../../../server/store/Memory.js";
-export default new MemoryStore();

package/source/server/Action.js

@@ -1,99 +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/InternalServer.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 {
-      return new (await import(path)).default(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};
-    };
-  }
-}