tutuca 0.9.19 → 0.9.20

package/dist/tutuca-dev.js

@@ -1701,9 +1701,14 @@ class ComponentStack {
       comp.scope = this.enter();
       this.comps.registerComponent(comp);
       this.byName[comp.name] = comp;
-      const alias = aliases[comp.name];
-      if (alias)
+    }
+    for (const alias in aliases) {
+      const comp = this.byName[aliases[alias]];
+      console.assert(this.byName[alias] === undefined, "alias overrides component", alias);
+      if (comp !== undefined)
         this.byName[alias] = comp;
+      else
+        console.warn("alias", alias, "to inexistent component", aliases[alias]);
     }
   }
   registerMacros(macros) {
@@ -2038,9 +2043,10 @@ class Transactor {
   }
 }
 function mkReq404(name) {
-  return () => {
+  const fn = () => {
     throw new Error(`Request not found: ${name}`);
   };
+  return { fn };
 }
 function nullHandler() {
   return this;
@@ -2681,15 +2687,13 @@ class App {
   _dispatchEvent(e) {
     const { type } = e;
     const isDrag = type === "dragover" || type === "dragstart" || type === "dragend";
-    const { rootNode: root, maxEventNodeDepth: maxDepth, comps } = this;
+    const { rootNode: root, maxEventNodeDepth: maxDepth, comps, transactor } = this;
     const [path, handlers] = Path.fromEvent(e, root, maxDepth, comps, !isDrag);
     if (isDrag)
       this._handleDragEvent(e, type, path);
-    if (path !== null && handlers !== null) {
-      for (const handler of handlers) {
-        this.transactor.transactInputNow(path, e, handler, this.dragInfo);
-      }
-    }
+    if (path !== null && handlers !== null)
+      for (const handler of handlers)
+        transactor.transactInputNow(path, e, handler, this.dragInfo);
   }
   _handleTouchEvent(e) {
     const { type } = e;
@@ -7932,7 +7936,7 @@ async function compileClassesToStyleText(app, compileClasses, extraCSSClasses, C
   }
   return await compileClasses(Array.from(classes));
 }
-// src/lint/index.js
+// tools/core/lint-check.js
 var ALT_HANDLER_NOT_DEFINED = "ALT_HANDLER_NOT_DEFINED";
 var RENDER_IT_OUTSIDE_OF_LOOP = "RENDER_IT_OUTSIDE_OF_LOOP";
 var UNKNOWN_EVENT_MODIFIER = "UNKNOWN_EVENT_MODIFIER";
@@ -8176,6 +8180,232 @@ class LintParseContext extends ParseContext {
     this.attrs.push({ attrs, wrapperAttrs, textChild });
   }
 }
+// tools/core/results.js
+class ComponentDocs {
+  constructor({ items }) {
+    this.items = items;
+  }
+}
+
+// tools/core/docs.js
+function getSignature(name, fn) {
+  const s = fn.toString();
+  const m = s.match(/^(?:\w+|function\s*\w*)\s*\(([^)]*)\)/);
+  const params = m ? m[1].trim() : "";
+  return `${name}(${params})`;
+}
+function getFieldMethods(field) {
+  const { name, type } = field;
+  const uname = name[0].toUpperCase() + name.slice(1);
+  const methods = [
+    { name: `set${uname}`, sig: `set${uname}(v)`, desc: "Set value" },
+    {
+      name: `update${uname}`,
+      sig: `update${uname}(fn)`,
+      desc: "Update value with function"
+    },
+    {
+      name: `reset${uname}`,
+      sig: `reset${uname}()`,
+      desc: "Reset to default value"
+    },
+    {
+      name: `is${uname}NotSet`,
+      sig: `is${uname}NotSet()`,
+      desc: "Check if null/undefined"
+    },
+    {
+      name: `is${uname}Set`,
+      sig: `is${uname}Set()`,
+      desc: "Check if not null/undefined"
+    }
+  ];
+  switch (type) {
+    case "bool":
+      methods[0].desc = "Set value (coerces to boolean)";
+      methods.push({
+        name: `toggle${uname}`,
+        sig: `toggle${uname}()`,
+        desc: "Toggle boolean value"
+      });
+      break;
+    case "text":
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: "Check if string is empty"
+      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get string length" });
+      break;
+    case "list":
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: "Check if list is empty"
+      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get list size" }, {
+        name: `setIn${uname}At`,
+        sig: `setIn${uname}At(i, v)`,
+        desc: "Set item at index"
+      }, {
+        name: `getIn${uname}At`,
+        sig: `getIn${uname}At(i, defaultValue)`,
+        desc: "Get item at index"
+      }, {
+        name: `updateIn${uname}At`,
+        sig: `updateIn${uname}At(i, fn)`,
+        desc: "Update item at index with function"
+      }, {
+        name: `deleteIn${uname}At`,
+        sig: `deleteIn${uname}At(i)`,
+        desc: "Delete item at index"
+      }, {
+        name: `removeIn${uname}At`,
+        sig: `removeIn${uname}At(i)`,
+        desc: "Delete item at index (alias)"
+      }, {
+        name: `pushIn${uname}`,
+        sig: `pushIn${uname}(v)`,
+        desc: "Push item to end"
+      }, {
+        name: `insertIn${uname}At`,
+        sig: `insertIn${uname}At(i, v)`,
+        desc: "Insert item at index"
+      });
+      break;
+    case "map":
+    case "omap": {
+      const label = type === "omap" ? "ordered map" : "map";
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: `Check if ${label} is empty`
+      }, {
+        name: `${name}Len`,
+        sig: `${name}Len()`,
+        desc: `Get ${label} size`
+      }, {
+        name: `setIn${uname}At`,
+        sig: `setIn${uname}At(key, v)`,
+        desc: "Set value at key"
+      }, {
+        name: `getIn${uname}At`,
+        sig: `getIn${uname}At(key, defaultValue)`,
+        desc: "Get value at key"
+      }, {
+        name: `updateIn${uname}At`,
+        sig: `updateIn${uname}At(key, fn)`,
+        desc: "Update value at key with function"
+      }, {
+        name: `deleteIn${uname}At`,
+        sig: `deleteIn${uname}At(key)`,
+        desc: "Delete entry at key"
+      }, {
+        name: `removeIn${uname}At`,
+        sig: `removeIn${uname}At(key)`,
+        desc: "Delete entry at key (alias)"
+      });
+      break;
+    }
+    case "set":
+      methods.push({
+        name: `is${uname}Empty`,
+        sig: `is${uname}Empty()`,
+        desc: "Check if set is empty"
+      }, { name: `${name}Len`, sig: `${name}Len()`, desc: "Get set size" }, {
+        name: `addIn${uname}`,
+        sig: `addIn${uname}(v)`,
+        desc: "Add value to set"
+      }, {
+        name: `deleteIn${uname}`,
+        sig: `deleteIn${uname}(v)`,
+        desc: "Remove value from set"
+      }, {
+        name: `removeIn${uname}`,
+        sig: `removeIn${uname}(v)`,
+        desc: "Remove value from set (alias)"
+      }, {
+        name: `hasIn${uname}`,
+        sig: `hasIn${uname}(v)`,
+        desc: "Check if value is in set"
+      }, {
+        name: `toggleIn${uname}`,
+        sig: `toggleIn${uname}(v)`,
+        desc: "Toggle value in set"
+      });
+      break;
+  }
+  return methods;
+}
+function serializeDefault(v) {
+  if (v === null || v === undefined)
+    return v;
+  if (v?.toJS)
+    return v.toJS();
+  return v;
+}
+function getComponentDoc(comp) {
+  const meta = comp.Class.getMetaClass();
+  const { fields, name, methods } = meta;
+  const userMethods = Object.keys(methods).map((k) => ({
+    name: k,
+    sig: getSignature(k, methods[k])
+  }));
+  const inputHandlers = Object.keys(comp.input).map((k) => ({
+    name: k,
+    sig: getSignature(k, comp.input[k])
+  }));
+  const fieldDocs = [];
+  for (const fieldName in fields) {
+    const field = fields[fieldName];
+    fieldDocs.push({
+      name: fieldName,
+      type: field.type,
+      default: serializeDefault(field.defaultValue),
+      methods: getFieldMethods(field)
+    });
+  }
+  return { name, methods: userMethods, input: inputHandlers, fields: fieldDocs };
+}
+function getComponentsDocs(components) {
+  return components.map((comp) => getComponentDoc(comp));
+}
+function docComponents(normalized, { name = null } = {}) {
+  const comps = normalized.components;
+  const picked = name === null ? comps : comps.filter((c) => c.name === name);
+  return new ComponentDocs({ items: getComponentsDocs(picked) });
+}
+// tools/format/lint.js
+function lintIdToMessage(id, info) {
+  switch (id) {
+    case "RENDER_IT_OUTSIDE_OF_LOOP":
+      return "render-it used outside of a loop";
+    case "UNKNOWN_EVENT_MODIFIER":
+      return `Unknown modifier '${info.modifier}' on '${info.name}' event`;
+    case "UNKNOWN_HANDLER_ARG_NAME":
+      return `Unknown handler argument '${info.name}'`;
+    case "INPUT_HANDLER_NOT_IMPLEMENTED":
+      return `Input handler '${info.name}' is not implemented`;
+    case "INPUT_HANDLER_METHOD_NOT_IMPLEMENTED":
+      return `Method '.${info.name}' is not implemented`;
+    case "INPUT_HANDLER_FOR_INPUT_HANDLER_METHOD":
+      return `'${info.name}' exists as input handler — use without '.' prefix`;
+    case "INPUT_HANDLER_METHOD_FOR_INPUT_HANDLER":
+      return `'${info.name}' exists as method — use with '.' prefix`;
+    case "FIELD_VAL_NOT_DEFINED":
+      return `Field '.${info.name}' is not defined`;
+    case "COMPUTED_VAL_NOT_DEFINED":
+      return `Computed property '$${info.name}' is not defined`;
+    case "UNKNOWN_REQUEST_NAME":
+      return `Unknown request '!${info.name}'`;
+    case "UNKNOWN_COMPONENT_NAME":
+      return `Unknown component '${info.name}'`;
+    case "ALT_HANDLER_NOT_DEFINED":
+      return `Alter handler '${info.name}' is not defined`;
+    case "LINT_ERROR":
+      return info.message;
+    default:
+      return id;
+  }
+}
 
 // dev.js
 class LintClassCollectorCtx extends ParseCtxClassSetCollector {
@@ -8211,6 +8441,7 @@ export {
   mergeDeep$1 as mergeDeep,
   merge$1 as merge,
   macro,
+  lintIdToMessage,
   isValueObject,
   isStack,
   isSet,
@@ -8236,9 +8467,11 @@ export {
   hasIn$1 as hasIn,
   has,
   getIn$1 as getIn,
+  getComponentsDocs,
   get,
   fromJS,
   fieldsByClass,
+  docComponents,
   css,
   component,
   compileClassesToStyleText,