@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/cjs/keys.js

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var keys_exports = {};
+__export(keys_exports, {
+  DOMQL_EVENTS: () => DOMQL_EVENTS,
+  DOMQ_PROPERTIES: () => DOMQ_PROPERTIES,
+  METHODS: () => METHODS,
+  METHODS_EXL: () => METHODS_EXL,
+  PARSED_DOMQ_PROPERTIES: () => PARSED_DOMQ_PROPERTIES,
+  PROPS_METHODS: () => PROPS_METHODS,
+  STATE_METHODS: () => STATE_METHODS,
+  STATE_PROPERTIES: () => STATE_PROPERTIES
+});
+module.exports = __toCommonJS(keys_exports);
+const DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "classlist",
+  "state",
+  "scope",
+  "root",
+  "deps",
+  "extend",
+  "extends",
+  "$router",
+  "routes",
+  "children",
+  "childExtend",
+  "childExtends",
+  "childExtendRecursive",
+  "childExtendsRecursive",
+  "props",
+  "if",
+  "define",
+  "__name",
+  "__ref",
+  "__hash",
+  "__text",
+  "key",
+  "tag",
+  "query",
+  "parent",
+  "node",
+  "variables",
+  "on",
+  "fetch",
+  "component",
+  "context",
+  "preventContentUpdate",
+  "preventContentRecreate"
+]);
+const PARSED_DOMQ_PROPERTIES = /* @__PURE__ */ new Set([
+  "attr",
+  "style",
+  "text",
+  "html",
+  "content",
+  "data",
+  "class",
+  "state",
+  "scope",
+  "children",
+  "props",
+  "if",
+  "key",
+  "tag",
+  "query",
+  "on",
+  "context"
+]);
+const STATE_PROPERTIES = [
+  "ref",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root"
+];
+const STATE_METHODS = /* @__PURE__ */ new Set([
+  "update",
+  "parse",
+  "clean",
+  "create",
+  "destroy",
+  "add",
+  "toggle",
+  "remove",
+  "apply",
+  "set",
+  "reset",
+  "replace",
+  "quietReplace",
+  "quietUpdate",
+  "applyReplace",
+  "applyFunction",
+  "keys",
+  "values",
+  "ref",
+  "rootUpdate",
+  "parentUpdate",
+  "parent",
+  "__element",
+  "__depends",
+  "__ref",
+  "__children",
+  "root",
+  "setByPath",
+  "setPathCollection",
+  "removeByPath",
+  "removePathCollection",
+  "getByPath"
+]);
+const PROPS_METHODS = /* @__PURE__ */ new Set(["update", "__element"]);
+const METHODS = /* @__PURE__ */ new Set([
+  "set",
+  "reset",
+  "update",
+  "remove",
+  "updateContent",
+  "removeContent",
+  "lookup",
+  "lookdown",
+  "lookdownAll",
+  "getRef",
+  "getPath",
+  "setNodeStyles",
+  "spotByPath",
+  "keys",
+  "parse",
+  "setProps",
+  "parseDeep",
+  "variables",
+  "if",
+  "log",
+  "verbose",
+  "warn",
+  "error",
+  "call",
+  "nextElement",
+  "previousElement",
+  "getRootState",
+  "getRoot",
+  "getRootData",
+  "getRootContext",
+  "getContext",
+  "getQuery",
+  "getDB",
+  "getChildren",
+  "preventContentUpdate",
+  "preventContentRecreate"
+]);
+const METHODS_EXL = /* @__PURE__ */ new Set([
+  "node",
+  "context",
+  "extends",
+  "__element",
+  "__ref",
+  ...METHODS,
+  ...STATE_METHODS,
+  ...PROPS_METHODS
+]);
+const DOMQL_EVENTS = /* @__PURE__ */ new Set([
+  "init",
+  "beforeClassAssign",
+  "render",
+  "renderRouter",
+  "attachNode",
+  "stateInit",
+  "stateCreated",
+  "beforeStateUpdate",
+  "stateUpdate",
+  "beforeUpdate",
+  "done",
+  "create",
+  "complete",
+  "frame",
+  "update",
+  "fetchError",
+  "fetchComplete"
+]);

package/dist/cjs/load.js

@@ -16,8 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/load.js
 var load_exports = {};
 __export(load_exports, {
   loadCssFile: () => loadCssFile,
@@ -29,7 +27,7 @@ __export(load_exports, {
   loadRemoteScript: () => loadRemoteScript
 });
 module.exports = __toCommonJS(load_exports);
-var loadJavascriptFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
+const loadJavascriptFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
   return new Promise((resolve, reject) => {
     try {
       const scriptEle = doc.createElement("script");
@@ -55,7 +53,7 @@ var loadJavascriptFile = (FILE_URL, async = false, doc = document, type = "text/
     }
   });
 };
-var loadJavascriptFileSync = (fileUrl, doc = document, type = "text/javascript") => {
+const loadJavascriptFileSync = (fileUrl, doc = document, type = "text/javascript") => {
   return new Promise((resolve, reject) => {
     const scriptEle = doc.createElement("script");
     scriptEle.type = type;
@@ -75,7 +73,7 @@ var loadJavascriptFileSync = (fileUrl, doc = document, type = "text/javascript")
     doc.body.appendChild(scriptEle);
   });
 };
-var loadJavascriptFileEmbedSync = (FILE_URL, doc = document, fallback, type = "text/javascript") => {
+const loadJavascriptFileEmbedSync = (FILE_URL, doc = document, fallback, type = "text/javascript") => {
   const xhr = new window.XMLHttpRequest();
   xhr.open("GET", FILE_URL, false);
   xhr.send();
@@ -89,7 +87,7 @@ var loadJavascriptFileEmbedSync = (FILE_URL, doc = document, fallback, type = "t
     throw new Error(`Failed to load the script ${FILE_URL}`);
   }
 };
-var loadCssFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
+const loadCssFile = (FILE_URL, async = false, doc = document, type = "text/javascript") => {
   return new Promise((resolve, reject) => {
     try {
       const linkElem = doc.createElement("link");
@@ -106,7 +104,7 @@ var loadCssFile = (FILE_URL, async = false, doc = document, type = "text/javascr
     }
   });
 };
-var loadJavascript = (body, async = false, doc = document, type = "text/javascript", id = "smbls-script") => {
+const loadJavascript = (body, async = false, doc = document, type = "text/javascript", id = "smbls-script") => {
   try {
     const scriptEle = doc.createElement("script");
     scriptEle.type = type;

package/dist/cjs/log.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var log_exports = {};
+__export(log_exports, {
+  logGroupIf: () => logGroupIf,
+  logIf: () => logIf
+});
+module.exports = __toCommonJS(log_exports);
+const logIf = (bool, ...arg) => {
+  if (bool) arg.map((v) => console.log(v));
+};
+const logGroupIf = (bool, key, ...arg) => {
+  if (bool) {
+    console.group(key);
+    arg.map((v) => console.log(v));
+    console.groupEnd(key);
+  }
+};

package/dist/cjs/metadata.js

@@ -0,0 +1,310 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var metadata_exports = {};
+__export(metadata_exports, {
+  generateMetaTags: () => generateMetaTags,
+  getPageMetadata: () => getPageMetadata
+});
+module.exports = __toCommonJS(metadata_exports);
+var import_types = require("./types.js");
+const escapeHtml = (text) => {
+  if (text === null || text === void 0) return "";
+  const map = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#039;" };
+  return text.toString().replace(/[&<>"']/g, (m) => map[m]);
+};
+const buildAttrs = (obj) => Object.entries(obj || {}).filter(([_, v]) => v !== void 0).map(([k, v]) => `${k}="${escapeHtml(v)}"`).join(" ");
+const generateMetaTags = (metadata, isProduction) => {
+  if (!isProduction) {
+    metadata = { ...metadata, robots: "noindex" };
+  }
+  const tags = Object.entries(metadata).reduce(
+    (acc, [key, value]) => {
+      if (!value && value !== 0 && value !== false) return acc;
+      if (key === "title") {
+        acc.push(`<title>${escapeHtml(value)}</title>`);
+        return acc;
+      }
+      if (key === "canonical") {
+        acc.push(`<link rel="canonical" href="${escapeHtml(value)}">`);
+        return acc;
+      }
+      if (key === "manifest") {
+        acc.push(`<link rel="manifest" href="${escapeHtml(value)}">`);
+        return acc;
+      }
+      if (key === "favicon" || key === "favicons" || key === "icon" || key === "icons") {
+        const items = Array.isArray(value) ? value : [value];
+        items.forEach((item) => {
+          if (typeof item === "string") {
+            acc.push(`<link rel="icon" href="${escapeHtml(item)}">`);
+          } else if (typeof item === "object") {
+            const attrs = buildAttrs(item);
+            if (!/rel=/.test(attrs)) {
+              acc.push(`<link rel="icon" ${attrs}>`);
+            } else {
+              acc.push(`<link ${attrs}>`);
+            }
+          }
+        });
+        return acc;
+      }
+      if (key === "alternate") {
+        const alternates = Array.isArray(value) ? value : [value];
+        alternates.forEach((alt) => {
+          if (typeof alt === "object") {
+            const attrs = Object.entries(alt).filter(([_, attrValue]) => attrValue !== void 0).map(([attrKey, attrValue]) => `${attrKey}="${escapeHtml(attrValue)}"`).join(" ");
+            acc.push(`<link rel="alternate" ${attrs}>`);
+          }
+        });
+        return acc;
+      }
+      const processMetaTag = (tagKey, tagValue, attrType = "name") => {
+        if (typeof tagValue === "string" || typeof tagValue === "number" || typeof tagValue === "boolean") {
+          acc.push(`<meta ${attrType}="${escapeHtml(tagKey)}" content="${escapeHtml(tagValue)}">`);
+        } else if (Array.isArray(tagValue)) {
+          tagValue.forEach((item) => {
+            if (typeof item === "string" || typeof item === "number" || typeof item === "boolean") {
+              acc.push(`<meta ${attrType}="${escapeHtml(tagKey)}" content="${escapeHtml(item)}">`);
+            } else if (typeof item === "object") {
+              const attrs = Object.entries(item).filter(([_, attrValue]) => attrValue !== void 0).map(([attrKey, attrValue]) => `${attrKey}="${escapeHtml(attrValue)}"`).join(" ");
+              acc.push(`<meta ${attrs}>`);
+            }
+          });
+        } else if (typeof tagValue === "object") {
+          const attrs = Object.entries(tagValue).filter(([_, attrValue]) => attrValue !== void 0).map(([attrKey, attrValue]) => `${attrKey}="${escapeHtml(attrValue)}"`).join(" ");
+          acc.push(`<meta ${attrs}>`);
+        }
+      };
+      if (key.startsWith("http-equiv:")) {
+        const httpEquivKey = key.replace("http-equiv:", "");
+        processMetaTag(httpEquivKey, value, "http-equiv");
+        return acc;
+      }
+      if (key.startsWith("itemprop:")) {
+        const itempropKey = key.replace("itemprop:", "");
+        processMetaTag(itempropKey, value, "itemprop");
+        return acc;
+      }
+      const prefixes = [
+        "og:",
+        "twitter:",
+        "fb:",
+        "article:",
+        "profile:",
+        "book:",
+        "business:",
+        "music:",
+        "product:",
+        "video:",
+        "DC:",
+        "DCTERMS:"
+      ];
+      const prefix = prefixes.find((p) => key.startsWith(p));
+      if (prefix) {
+        const tagKey = key.replace(prefix, "");
+        processMetaTag(
+          `${prefix.replace(":", "")}:${tagKey}`,
+          value,
+          prefix === "twitter:" || prefix === "DC:" || prefix === "DCTERMS:" ? "name" : "property"
+        );
+        return acc;
+      }
+      if (key.startsWith("apple:") || key.startsWith("msapplication:")) {
+        const pfx = key.startsWith("apple:") ? "apple-" : "msapplication-";
+        const tagKey = key.replace(/^apple:|^msapplication:/, "");
+        processMetaTag(`${pfx}${tagKey}`, value, "name");
+        return acc;
+      }
+      processMetaTag(key, value);
+      return acc;
+    },
+    [
+      '<meta charset="UTF-8">',
+      '<meta name="viewport" content="width=device-width, initial-scale=1, minimum-scale=1, maximum-scale=1, user-scalable=no">'
+    ]
+  );
+  return tags.join("\n");
+};
+const isBareFilename = (val) => typeof val === "string" && val.length > 0 && !val.startsWith("/") && !val.startsWith("http");
+function resolveFileReferences(metadata, files) {
+  if (!files || typeof files !== "object") return metadata;
+  const resolve = (val) => {
+    if (!isBareFilename(val)) return val;
+    const fileEntry = files[val];
+    if (fileEntry?.src) return fileEntry.src;
+    return val;
+  };
+  const result = { ...metadata };
+  for (const [key, value] of Object.entries(result)) {
+    if (typeof value === "string") {
+      result[key] = resolve(value);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map(
+        (item) => typeof item === "string" ? resolve(item) : item
+      );
+    }
+  }
+  return result;
+}
+function resolveDotPath(obj, path) {
+  if (!obj || !path) return void 0;
+  const parts = path.split(".");
+  let v = obj;
+  for (const p of parts) {
+    if (v == null || typeof v !== "object") return void 0;
+    v = v[p];
+  }
+  return v;
+}
+function resolveMetadataTemplates(metadata, data, ssrContext) {
+  const config = data.config || data.settings || {};
+  const polyglot = config.polyglot || data.polyglot;
+  const defaultLang = ssrContext?.lang || polyglot?.defaultLang || "en";
+  const translations = polyglot?.translations || {};
+  const langMap = translations[defaultLang] || {};
+  const state = ssrContext?.state || {};
+  const result = { ...metadata };
+  for (const [key, value] of Object.entries(result)) {
+    if (typeof value !== "string" || !value.includes("{{")) continue;
+    result[key] = value.replace(/\{\{\s*([^|{}]+?)\s*(?:\|\s*(\w+)\s*)?\}\}/g, (match, k, filter) => {
+      const trimmed = k.trim();
+      if (filter === "polyglot") {
+        return langMap[trimmed] ?? resolveDotPath(langMap, trimmed) ?? match;
+      }
+      if (filter === "getLocalStateLang") {
+        const resolved = resolveDotPath(state, trimmed + defaultLang);
+        return resolved ?? match;
+      }
+      const fromState = resolveDotPath(state, trimmed);
+      if (fromState !== void 0) return fromState;
+      return langMap[trimmed] ?? resolveDotPath(langMap, trimmed) ?? match;
+    });
+  }
+  return result;
+}
+function convertFunctionMetaToTemplates(metadata) {
+  const result = { ...metadata };
+  for (const [key, value] of Object.entries(result)) {
+    if (typeof value === "function") {
+      const src = value.toString();
+      const langMatch = src.match(/el\.call\(\s*["']getLocalStateLang["']\s*,\s*["']([^"']+)["']\s*\)/);
+      if (langMatch) {
+        result[key] = `{{ ${langMatch[1]} | getLocalStateLang }}`;
+        continue;
+      }
+      const polyMatch = src.match(/el\.call\(\s*["']polyglot["']\s*,\s*["']([^"']+)["']\s*\)/);
+      if (polyMatch) {
+        result[key] = `{{ ${polyMatch[1]} | polyglot }}`;
+        continue;
+      }
+      const stateMatch = src.match(/s\.(\w+(?:\.\w+)+)/);
+      if (stateMatch) {
+        result[key] = `{{ ${stateMatch[1]} }}`;
+        continue;
+      }
+      delete result[key];
+    } else if (typeof value === "string") {
+      const langMatch = value.match(/el\.call\(\s*["']getLocalStateLang["']\s*,\s*["']([^"']+)["']\s*\)/);
+      if (langMatch) {
+        result[key] = `{{ ${langMatch[1]} | getLocalStateLang }}`;
+        continue;
+      }
+      const polyMatch = value.match(/el\.call\(\s*["']polyglot["']\s*,\s*["']([^"']+)["']\s*\)/);
+      if (polyMatch) {
+        result[key] = `{{ ${polyMatch[1]} | polyglot }}`;
+        continue;
+      }
+      if (value.includes("=>") && value.includes("s.")) {
+        const stateMatch = value.match(/s\.(\w+(?:\.\w+)+)/);
+        if (stateMatch) {
+          result[key] = `{{ ${stateMatch[1]} }}`;
+          continue;
+        }
+      }
+    }
+  }
+  return result;
+}
+function getPageMetadata(data, pathname, ssrContext, { isProduction = false, channel = "production" } = {}) {
+  const currentPage = data.pages?.[pathname];
+  const stateObject = (0, import_types.isObject)(currentPage?.state) && currentPage?.state;
+  const rawPageMeta = currentPage?.metadata || currentPage?.helmet || stateObject || {};
+  const pageMetadata = convertFunctionMetaToTemplates(rawPageMeta);
+  const pageExplicitKeys = new Set(Object.keys(pageMetadata));
+  const appMetadata = data.app?.metadata || {};
+  const cleanAppMeta = convertFunctionMetaToTemplates(appMetadata);
+  let merged = {};
+  if (data.integrations?.seo) {
+    merged = { ...data.integrations.seo, ...cleanAppMeta, ...pageMetadata };
+  } else if (Object.keys(cleanAppMeta).length) {
+    merged = { ...cleanAppMeta, ...pageMetadata };
+  } else {
+    merged = { ...pageMetadata };
+  }
+  if (!merged.title) {
+    const label = data.name || data.key;
+    if (label) {
+      if (isProduction) merged.title = label;
+      else if (channel === "development") merged.title = `${label} / dev:symbo.ls`;
+      else if (channel === "staging") merged.title = `${label} / staging:symbo.ls`;
+      else merged.title = `${label} / symbo.ls`;
+    } else {
+      merged.title = "Symbols demo";
+    }
+  }
+  merged = resolveMetadataTemplates(merged, data, ssrContext);
+  if (merged.title && (pageExplicitKeys.has("title") || !merged["og:title"])) {
+    if (!pageExplicitKeys.has("og:title")) {
+      merged["og:title"] = merged.title;
+    }
+  }
+  if (merged.description && (pageExplicitKeys.has("description") || !merged["og:description"])) {
+    if (!pageExplicitKeys.has("og:description")) {
+      merged["og:description"] = merged.description;
+    }
+  }
+  if (merged.title && !merged["twitter:title"]) {
+    merged["twitter:title"] = merged.title;
+  }
+  if (merged.description && !merged["twitter:description"]) {
+    merged["twitter:description"] = merged.description;
+  }
+  const routeForUrl = ssrContext?.actualPathname || pathname;
+  if (merged["og:url"] || merged.url) {
+    const baseUrl = (merged["og:url"] || merged.url || "").replace(/\/$/, "");
+    if (baseUrl && routeForUrl && routeForUrl !== "/") {
+      const cleanRoute = routeForUrl.startsWith("/") ? routeForUrl : "/" + routeForUrl;
+      merged["og:url"] = baseUrl + cleanRoute;
+    }
+  }
+  merged = resolveFileReferences(merged, data.files);
+  const siteName = data.name || data.app?.metadata?.title || data.app?.name || "";
+  for (const [key, value] of Object.entries(merged)) {
+    if (typeof value === "string" && value.includes("{{")) {
+      const cleaned = value.replace(/\{\{[^}]*\}\}/g, "").trim();
+      if (!cleaned) {
+        if (key === "title") merged[key] = siteName;
+        else delete merged[key];
+      } else {
+        merged[key] = cleaned;
+      }
+    }
+  }
+  return merged;
+}