@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/cjs/props.js

@@ -0,0 +1,282 @@
+"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 props_exports = {};
+__export(props_exports, {
+  applyProps: () => applyProps,
+  createProps: () => createProps,
+  createPropsStack: () => createPropsStack,
+  inheritParentProps: () => inheritParentProps,
+  initProps: () => initProps,
+  objectizeStringProperty: () => objectizeStringProperty,
+  pickupElementFromProps: () => pickupElementFromProps,
+  pickupPropsFromElement: () => pickupPropsFromElement,
+  propExists: () => propExists,
+  propertizeElement: () => propertizeElement,
+  propertizeUpdate: () => propertizeUpdate,
+  removeDuplicateProps: () => removeDuplicateProps,
+  setPropsPrototype: () => setPropsPrototype,
+  syncProps: () => syncProps,
+  update: () => update,
+  updateProps: () => updateProps
+});
+module.exports = __toCommonJS(props_exports);
+var import_keys = require("./keys.js");
+var import_events = require("./events.js");
+var import_object = require("./object.js");
+var import_types = require("./types.js");
+var import_string = require("./string.js");
+var import_function = require("./function.js");
+const RE_UPPER = /^[A-Z]/;
+const RE_DIGITS = /^\d+$/;
+const CSS_SELECTOR_PREFIXES = /* @__PURE__ */ new Set([":", "@", "[", "*", "+", "~", "&", ">", "$", "-", ".", "!"]);
+const ELEMENT_INDICATOR_KEYS = /* @__PURE__ */ new Set([
+  "extend",
+  "props",
+  "text",
+  "tag",
+  "on",
+  "if",
+  "childExtend",
+  "children",
+  "childrenAs",
+  "state",
+  "html",
+  "attr",
+  "define",
+  "content"
+]);
+const looksLikeElement = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  for (const k in value) {
+    if (ELEMENT_INDICATOR_KEYS.has(k)) return true;
+    if (RE_UPPER.test(k)) return true;
+  }
+  return false;
+};
+const createProps = (element, parent, key) => {
+  const { props, __ref: ref } = element;
+  ref.__propsStack = [];
+  if (props) ref.__initialProps = props;
+  else return {};
+  if (!(0, import_types.isObjectLike)(props)) {
+    ref.__propsStack.push(props);
+    return {};
+  }
+  return { ...props };
+};
+function pickupPropsFromElement(obj, opts = {}) {
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in obj) {
+    const value = obj[key];
+    const isOnKey = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && key[2] === key[2].toUpperCase();
+    const isEventHandler = isOnKey && ((0, import_types.isFunction)(value) || value != null && (0, import_function.hasHandlerPlugin)(this.context));
+    if (isEventHandler) {
+      const eventName = (0, import_string.lowercaseFirstLetter)(key.slice(2));
+      if (obj.on) obj.on[eventName] = value;
+      delete obj[key];
+      continue;
+    }
+    if (key === "childProps") {
+      obj.props[key] = value;
+      delete obj[key];
+      cachedKeys.push(key);
+      continue;
+    }
+    const defineValue = this.define?.[key];
+    const globalDefineValue = this.context?.define?.[key];
+    const hasDefine = (0, import_types.isObject)(defineValue) || (0, import_types.isFunction)(defineValue);
+    const hasGlobalDefine = (0, import_types.isObject)(globalDefineValue) || (0, import_types.isFunction)(globalDefineValue);
+    if (hasDefine || hasGlobalDefine) continue;
+    const firstChar = key.charAt(0);
+    if (CSS_SELECTOR_PREFIXES.has(firstChar)) {
+      obj.props[key] = value;
+      delete obj[key];
+      cachedKeys.push(key);
+      continue;
+    }
+    const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key) || looksLikeElement(value);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.has(key);
+    if (!isElement && !isBuiltin) {
+      if (!(key in obj.props)) obj.props[key] = value;
+      delete obj[key];
+      cachedKeys.push(key);
+    }
+  }
+  return obj;
+}
+function pickupElementFromProps(obj = this, opts) {
+  const cachedKeys = opts.cachedKeys || [];
+  for (const key in obj.props) {
+    const value = obj.props[key];
+    const isEvent = key.length > 2 && key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110;
+    const isHandler = (0, import_types.isFunction)(value) || value != null && (0, import_function.hasHandlerPlugin)(this.context);
+    if (isEvent && isHandler) {
+      (0, import_events.addEventFromProps)(key, obj);
+      delete obj.props[key];
+      continue;
+    }
+    if (cachedKeys.includes(key)) continue;
+    if (key === "childProps") continue;
+    const firstChar = key.charAt(0);
+    if (CSS_SELECTOR_PREFIXES.has(firstChar)) continue;
+    const defineValue = this.define?.[key];
+    const globalDefineValue = this.context?.define?.[key];
+    const hasDefine = (0, import_types.isObject)(defineValue) || (0, import_types.isFunction)(defineValue);
+    const hasGlobalDefine = (0, import_types.isObject)(globalDefineValue) || (0, import_types.isFunction)(globalDefineValue);
+    const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+    const isBuiltin = import_keys.DOMQ_PROPERTIES.has(key);
+    if (isElement || isBuiltin || hasDefine || hasGlobalDefine) {
+      if (obj[key] === void 0 || value === null) {
+        obj[key] = value;
+        if (obj.props) delete obj.props[key];
+      }
+    }
+  }
+  return obj;
+}
+function propertizeElement(element = this) {
+  const cachedKeys = [];
+  pickupPropsFromElement.call(this, element, { cachedKeys });
+  pickupElementFromProps.call(this, element, { cachedKeys });
+  return element;
+}
+function propertizeUpdate(params = {}) {
+  if (!params.on) params.on = {};
+  if (!params.props) params.props = {};
+  return propertizeElement.call(this, params);
+}
+const objectizeStringProperty = (propValue) => {
+  if ((0, import_types.is)(propValue)("string", "number")) {
+    return { inheritedString: propValue };
+  }
+  return propValue;
+};
+const propExists = (prop, stack) => {
+  if (!prop || !stack.length) return false;
+  return stack.includes(prop);
+};
+const inheritParentProps = (element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  const parentProps = parent.props;
+  if (!parentProps) return propsStack;
+  const matchParentKeyProps = parentProps[element.key];
+  const matchParentChildProps = parentProps.childProps || parent.childProps;
+  const ignoreChildProps = element.props?.ignoreChildProps;
+  if (matchParentChildProps && !ignoreChildProps) {
+    const childProps = objectizeStringProperty(matchParentChildProps);
+    propsStack.unshift(childProps);
+  }
+  if (matchParentKeyProps) {
+    const keyProps = objectizeStringProperty(matchParentKeyProps);
+    propsStack.unshift(keyProps);
+  }
+  return propsStack;
+};
+function update(props, options) {
+  const element = this.__element;
+  element.update({ props }, options);
+}
+function setPropsPrototype(element) {
+  const methods = { update: update.bind(element.props), __element: element };
+  Object.setPrototypeOf(element.props, methods);
+}
+const removeDuplicateProps = (propsStack) => {
+  const seen = /* @__PURE__ */ new Set();
+  return propsStack.filter((prop) => {
+    if (!prop || import_keys.PROPS_METHODS.has(prop)) return false;
+    if (seen.has(prop)) return false;
+    seen.add(prop);
+    return true;
+  });
+};
+const syncProps = (propsStack, element, opts) => {
+  element.props = propsStack.reduce((mergedProps, v) => {
+    if (import_keys.PROPS_METHODS.has(v)) return mergedProps;
+    while ((0, import_types.isFunction)(v)) v = (0, import_object.exec)(v, element);
+    return (0, import_object.deepMerge)(mergedProps, (0, import_object.deepClone)(v, { exclude: import_keys.PROPS_METHODS }));
+  }, {});
+  setPropsPrototype(element);
+  return element.props;
+};
+const createPropsStack = (element, parent) => {
+  const { props, __ref: ref } = element;
+  let propsStack = ref.__propsStack || [];
+  if (parent?.props) {
+    const parentStack = inheritParentProps(element, parent);
+    propsStack = [...parentStack];
+  }
+  if ((0, import_types.isObject)(props)) propsStack.push(props);
+  else if (props === "inherit" && parent?.props) propsStack.push(parent.props);
+  else if (props) propsStack.push(props);
+  if ((0, import_types.isArray)(ref.__extendsStack)) {
+    for (let i = 0; i < ref.__extendsStack.length; i++) {
+      const _extends = ref.__extendsStack[i];
+      if (_extends.props && _extends.props !== props) {
+        propsStack.push(_extends.props);
+      }
+    }
+  }
+  ref.__propsStack = removeDuplicateProps(propsStack);
+  return ref.__propsStack;
+};
+const applyProps = (element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = createPropsStack(element, parent);
+  if (propsStack.length) {
+    syncProps(propsStack, element);
+  } else {
+    ref.__propsStack = [];
+    element.props = {};
+  }
+};
+const initProps = function(element, parent, options) {
+  const { __ref: ref } = element;
+  if (ref.__if) applyProps(element, parent);
+  else {
+    try {
+      applyProps(element, parent);
+    } catch (e) {
+      if (element.context?.designSystem?.verbose) {
+        console.warn("initProps error at", ref.path?.join("."), e);
+      }
+      element.props = {};
+      ref.__propsStack = [];
+    }
+  }
+  setPropsPrototype(element);
+  return element;
+};
+const updateProps = (newProps, element, parent) => {
+  const { __ref: ref } = element;
+  const propsStack = ref.__propsStack || [];
+  let newStack = [...propsStack];
+  const parentProps = inheritParentProps(element, parent);
+  if (parentProps.length) {
+    newStack = [...parentProps, ...newStack];
+  }
+  if (newProps) {
+    newStack = [newProps, ...newStack];
+  }
+  ref.__propsStack = removeDuplicateProps(newStack);
+  if (ref.__propsStack.length) {
+    syncProps(ref.__propsStack, element);
+  }
+  return element;
+};

package/dist/cjs/scaling.js

@@ -16,184 +16,20 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/scaling.js
 var scaling_exports = {};
 __export(scaling_exports, {
   findClosestNumber: () => findClosestNumber,
   findClosestNumberInFactory: () => findClosestNumberInFactory
 });
 module.exports = __toCommonJS(scaling_exports);
-
-// ../../../domql/packages/utils/dist/esm/globals.js
-var window2 = globalThis;
-var document2 = window2.document;
-
-// ../../../domql/packages/utils/dist/esm/types.js
-var isObject = (arg) => {
-  if (arg === null) return false;
-  return typeof arg === "object" && arg.constructor === Object;
-};
-var isArray = (arg) => Array.isArray(arg);
-
-// ../../../domql/packages/utils/dist/esm/keys.js
-var STATE_METHODS = [
-  "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"
-];
-var PROPS_METHODS = ["update", "__element"];
-var METHODS = [
-  "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"
-];
-var METHODS_EXL = [
-  ...["node", "context", "extends", "__element", "__ref"],
-  ...METHODS,
-  ...STATE_METHODS,
-  ...PROPS_METHODS
-];
-
-// ../../../domql/packages/utils/dist/esm/cookie.js
-var isMobile = (() => typeof navigator === "undefined" ? false : /Mobi/.test(navigator.userAgent))();
-
-// ../../../domql/packages/event/dist/esm/keys.js
-var STATE_METHODS2 = [
-  "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"
-];
-var PROPS_METHODS2 = ["update", "__element"];
-var METHODS2 = [
-  "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"
-];
-var METHODS_EXL2 = [
-  ...["node", "context", "extends", "__element", "__ref"],
-  ...METHODS2,
-  ...STATE_METHODS2,
-  ...PROPS_METHODS2
-];
-
-// ../../../domql/packages/event/dist/esm/globals.js
-var window3 = globalThis;
-var document3 = window3.document;
-
-// src/scaling.js
-var findClosestNumber = (number, arr) => {
-  return (isArray(arr) ? arr : Object.values(arr)).reduce((prev, curr) => {
+var import_types = require("./types.js");
+const findClosestNumber = (number, arr) => {
+  return ((0, import_types.isArray)(arr) ? arr : Object.values(arr)).reduce((prev, curr) => {
     return Math.abs(curr - number) < Math.abs(prev - number) ? curr : prev;
   });
 };
-var findClosestNumberInFactory = (val, factory) => {
+const findClosestNumberInFactory = (val, factory) => {
   val = parseFloat(val);
-  if (isObject(factory)) factory = Object.values(factory);
+  if ((0, import_types.isObject)(factory)) factory = Object.values(factory);
   return findClosestNumber(val, factory);
 };
-// @preserve-env

package/dist/cjs/scope.js

@@ -0,0 +1,44 @@
+"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 scope_exports = {};
+__export(scope_exports, {
+  createScope: () => createScope
+});
+module.exports = __toCommonJS(scope_exports);
+const createScope = (element, parent) => {
+  const { __ref: ref } = element;
+  const context = element.context || parent.context || ref.root?.context;
+  if (context && !context.globalScope) context.globalScope = {};
+  const parentScope = parent.scope || ref.root?.scope;
+  const globalScope = context?.globalScope;
+  if (!element.scope) {
+    if (parentScope) {
+      element.scope = parentScope;
+    } else if (globalScope) {
+      element.scope = Object.create(globalScope);
+    } else {
+      element.scope = {};
+    }
+  } else if (typeof element.scope === "object" && element.scope !== null) {
+    if (Object.getPrototypeOf(element.scope) === Object.prototype) {
+      const proto = parentScope || globalScope;
+      if (proto) Object.setPrototypeOf(element.scope, proto);
+    }
+  }
+};

package/dist/cjs/sharedLibraries.js

@@ -0,0 +1,146 @@
+"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 sharedLibraries_exports = {};
+__export(sharedLibraries_exports, {
+  deepDefaults: () => deepDefaults,
+  fetchLibraryData: () => fetchLibraryData,
+  mergeSharedLibraries: () => mergeSharedLibraries,
+  normalizeLibraryKey: () => normalizeLibraryKey,
+  resolveSharedLibraries: () => resolveSharedLibraries
+});
+module.exports = __toCommonJS(sharedLibraries_exports);
+var import_types = require("./types.js");
+const DEFAULT_LIBRARY_OWNER = "system";
+const KV_BASE_URL = "https://smbls-kv.nika-980.workers.dev";
+const API_BASE_URL = "https://api.symbols.app";
+function normalizeLibraryKey(raw) {
+  const s = String(raw || "").trim();
+  if (!s) return { owner: DEFAULT_LIBRARY_OWNER, key: "", full: "" };
+  let owner = null;
+  let key = s;
+  if (s.includes("/")) {
+    const idx = s.indexOf("/");
+    owner = s.slice(0, idx);
+    key = s.slice(idx + 1);
+  }
+  key = key.replace(/\.symbo\.ls$/iu, "");
+  if (!owner) owner = DEFAULT_LIBRARY_OWNER;
+  const full = key ? `${owner}/${key}` : "";
+  return { owner, key, full };
+}
+const deepDefaults = (target, source) => {
+  for (const k in source) {
+    if (!(k in target)) {
+      target[k] = source[k];
+    } else if ((0, import_types.isObject)(target[k]) && (0, import_types.isObject)(source[k])) {
+      deepDefaults(target[k], source[k]);
+    }
+  }
+};
+const mergeSharedLibraries = (context, libraries) => {
+  if (!libraries || !libraries.length) return;
+  for (let i = 0; i < libraries.length; i++) {
+    const sharedLib = libraries[i];
+    if (!(0, import_types.isObject)(sharedLib)) continue;
+    for (const key in sharedLib) {
+      if (!Object.prototype.hasOwnProperty.call(sharedLib, key)) continue;
+      if ((0, import_types.isObject)(sharedLib[key]) && (0, import_types.isObject)(context[key])) {
+        if (key === "designSystem") {
+          deepDefaults(context[key], sharedLib[key]);
+        } else {
+          for (const k in sharedLib[key]) {
+            if (!(k in context[key])) context[key][k] = sharedLib[key][k];
+          }
+        }
+      } else if (!(key in context)) {
+        context[key] = sharedLib[key];
+      }
+    }
+  }
+};
+async function fetchLibraryData(identifier, opts = {}) {
+  const provider = opts.provider || "kv";
+  if (provider === "api") {
+    return fetchLibraryFromApi(identifier, opts);
+  }
+  const result = await fetchLibraryFromKv(identifier, opts);
+  if (result) return result;
+  return fetchLibraryFromApi(identifier, opts);
+}
+async function fetchLibraryFromKv(identifier, opts = {}) {
+  const baseUrl = opts.kvBaseUrl || KV_BASE_URL;
+  const env = opts.env || "production";
+  const url = `${baseUrl}/kv/${encodeURIComponent(identifier)}?env=${env}`;
+  try {
+    const response = await fetch(url, { method: "GET" });
+    if (!response.ok) return null;
+    const json = await response.json();
+    return json?.value || null;
+  } catch {
+    return null;
+  }
+}
+async function fetchLibraryFromApi(identifier, opts = {}) {
+  const baseUrl = opts.apiBaseUrl || API_BASE_URL;
+  const { key } = normalizeLibraryKey(identifier);
+  try {
+    const listUrl = `${baseUrl}/core/projects/libraries/available?search=${encodeURIComponent(key)}&limit=10`;
+    const listRes = await fetch(listUrl, { method: "GET" });
+    if (!listRes.ok) return null;
+    const listJson = await listRes.json();
+    const items = listJson?.items || listJson?.data || (Array.isArray(listJson) ? listJson : []);
+    const match = items.find((lib) => {
+      const { key: libKey } = normalizeLibraryKey(lib?.key);
+      return libKey.toLowerCase() === key.toLowerCase();
+    });
+    if (!match?.id && !match?._id) return null;
+    const libId = match.id || match._id;
+    const dataUrl = `${baseUrl}/core/projects/${encodeURIComponent(libId)}/data?branch=main`;
+    const dataRes = await fetch(dataUrl, { method: "GET" });
+    if (!dataRes.ok) return null;
+    const dataJson = await dataRes.json();
+    return dataJson?.data || dataJson || null;
+  } catch {
+    return null;
+  }
+}
+async function resolveSharedLibraries(libraries, opts = {}) {
+  if (!libraries || !libraries.length) return [];
+  const resolved = await Promise.all(
+    libraries.map(async (entry) => {
+      if ((0, import_types.isObject)(entry)) return entry;
+      if ((0, import_types.isString)(entry)) {
+        const { full } = normalizeLibraryKey(entry);
+        if (!full) return null;
+        try {
+          const data = await fetchLibraryData(full, opts);
+          if (!data) {
+            console.warn(`[smbls] Shared library "${full}" not found`);
+          }
+          return data;
+        } catch (e) {
+          console.warn(`[smbls] Failed to fetch shared library "${full}":`, e.message);
+          return null;
+        }
+      }
+      return null;
+    })
+  );
+  return resolved.filter(Boolean);
+}