@symbo.ls/utils 3.2.3 → 3.14.0

package/dist/esm/props.js

@@ -0,0 +1,262 @@
+import { DOMQ_PROPERTIES, PROPS_METHODS } from "./keys.js";
+import { addEventFromProps } from "./events.js";
+import { deepClone, deepMerge, exec } from "./object.js";
+import { is, isArray, isFunction, isObject, isObjectLike } from "./types.js";
+import { lowercaseFirstLetter } from "./string.js";
+import { hasHandlerPlugin } from "./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 (!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 && (isFunction(value) || value != null && hasHandlerPlugin(this.context));
+    if (isEventHandler) {
+      const eventName = 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 = isObject(defineValue) || isFunction(defineValue);
+    const hasGlobalDefine = isObject(globalDefineValue) || 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 = 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 = isFunction(value) || value != null && hasHandlerPlugin(this.context);
+    if (isEvent && isHandler) {
+      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 = isObject(defineValue) || isFunction(defineValue);
+    const hasGlobalDefine = isObject(globalDefineValue) || isFunction(globalDefineValue);
+    const isElement = RE_UPPER.test(key) || RE_DIGITS.test(key);
+    const isBuiltin = 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 (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 || 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 (PROPS_METHODS.has(v)) return mergedProps;
+    while (isFunction(v)) v = exec(v, element);
+    return deepMerge(mergedProps, deepClone(v, { exclude: 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 (isObject(props)) propsStack.push(props);
+  else if (props === "inherit" && parent?.props) propsStack.push(parent.props);
+  else if (props) propsStack.push(props);
+  if (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;
+};
+export {
+  applyProps,
+  createProps,
+  createPropsStack,
+  inheritParentProps,
+  initProps,
+  objectizeStringProperty,
+  pickupElementFromProps,
+  pickupPropsFromElement,
+  propExists,
+  propertizeElement,
+  propertizeUpdate,
+  removeDuplicateProps,
+  setPropsPrototype,
+  syncProps,
+  update,
+  updateProps
+};

package/dist/esm/scaling.js

@@ -0,0 +1,15 @@
+import { isObject, isArray } from "./types.js";
+const findClosestNumber = (number, arr) => {
+  return (isArray(arr) ? arr : Object.values(arr)).reduce((prev, curr) => {
+    return Math.abs(curr - number) < Math.abs(prev - number) ? curr : prev;
+  });
+};
+const findClosestNumberInFactory = (val, factory) => {
+  val = parseFloat(val);
+  if (isObject(factory)) factory = Object.values(factory);
+  return findClosestNumber(val, factory);
+};
+export {
+  findClosestNumber,
+  findClosestNumberInFactory
+};

package/dist/esm/scope.js

@@ -0,0 +1,24 @@
+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);
+    }
+  }
+};
+export {
+  createScope
+};

package/dist/esm/sharedLibraries.js

@@ -0,0 +1,126 @@
+import { isObject, isString } from "./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 (isObject(target[k]) && 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 (!isObject(sharedLib)) continue;
+    for (const key in sharedLib) {
+      if (!Object.prototype.hasOwnProperty.call(sharedLib, key)) continue;
+      if (isObject(sharedLib[key]) && 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 (isObject(entry)) return entry;
+      if (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);
+}
+export {
+  deepDefaults,
+  fetchLibraryData,
+  mergeSharedLibraries,
+  normalizeLibraryKey,
+  resolveSharedLibraries
+};

package/dist/esm/state.js

@@ -0,0 +1,163 @@
+import { addProtoToArray } from "./array.js";
+import { STATE_METHODS } from "./keys.js";
+import {
+  deepClone,
+  deepMerge,
+  overwriteDeep,
+  overwriteShallow
+} from "./object.js";
+import {
+  is,
+  isObject,
+  isObjectLike,
+  isString
+} from "./types.js";
+const checkForStateTypes = (element) => {
+  const { state: orig, props, __ref: ref } = element;
+  const state = props?.state || orig;
+  if (is(state)("string", "number")) {
+    ref.__state = state;
+    return { value: state };
+  } else if (state === true) {
+    ref.__state = element.key;
+    return {};
+  } else if (state) {
+    ref.__hasRootState = true;
+    return state;
+  } else {
+    return false;
+  }
+};
+const getRootStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("~/")) return;
+  const arr = stateKey.split("~/");
+  if (arr.length > 1) return parentState.root;
+};
+const getParentStateInKey = (stateKey, parentState) => {
+  if (!stateKey.includes("../")) return;
+  const arr = stateKey.split("../");
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    if (!parentState.parent) return null;
+    parentState = parentState.parent;
+  }
+  return parentState;
+};
+const getChildStateInKey = (stateKey, parentState, options = {}) => {
+  const arr = isString(stateKey) ? stateKey.split("/") : [stateKey];
+  const arrLength = arr.length - 1;
+  for (let i = 0; i < arrLength; i++) {
+    const childKey = arr[i];
+    const grandChildKey = arr[i + 1];
+    if (childKey === "__proto__" || grandChildKey === "__proto__") return;
+    let childInParent = parentState[childKey];
+    if (!childInParent) childInParent = parentState[childKey] = {};
+    if (!childInParent[grandChildKey]) childInParent[grandChildKey] = {};
+    stateKey = grandChildKey;
+    parentState = childInParent;
+  }
+  if (options.returnParent) return parentState;
+  return parentState[stateKey];
+};
+const findInheritedState = (element, parent, options = {}) => {
+  const ref = element.__ref;
+  let stateKey = ref.__state;
+  if (!checkIfInherits(element)) return;
+  const rootState = getRootStateInKey(stateKey, parent.state);
+  let parentState = parent.state;
+  if (rootState) {
+    parentState = rootState;
+    stateKey = stateKey.replaceAll("~/", "");
+  } else {
+    const findGrandParentState = getParentStateInKey(stateKey, parent.state);
+    if (findGrandParentState) {
+      parentState = findGrandParentState;
+      stateKey = stateKey.replaceAll("../", "");
+    }
+  }
+  if (!parentState) return;
+  return getChildStateInKey(stateKey, parentState, options);
+};
+const createInheritedState = (element, parent) => {
+  const ref = element.__ref;
+  const inheritedState = findInheritedState(element, parent);
+  if (inheritedState === void 0) return element.state;
+  if (is(inheritedState)("object", "array")) {
+    return deepClone(inheritedState);
+  } else if (is(inheritedState)("string", "number", "boolean")) {
+    ref.__stateType = typeof inheritedState;
+    return { value: inheritedState };
+  }
+  console.warn(ref.__state, "is not present. Replacing with", {});
+};
+const checkIfInherits = (element) => {
+  const { __ref: ref } = element;
+  const stateKey = ref?.__state;
+  if (stateKey && is(stateKey)("number", "string", "boolean")) return true;
+  return false;
+};
+const isState = function(state) {
+  if (!isObjectLike(state)) return false;
+  return Boolean(
+    state.update && state.parse && state.clean && state.create && state.parent && state.destroy && state.rootUpdate && state.parentUpdate && state.keys && state.values && state.toggle && state.replace && state.quietUpdate && state.quietReplace && state.add && state.apply && state.applyReplace && state.setByPath && state.setPathCollection && state.removeByPath && state.removePathCollection && state.getByPath && state.applyFunction && state.__element && state.__children
+  );
+};
+const createNestedObjectByKeyPath = (path, value) => {
+  if (!path) {
+    return value || {};
+  }
+  const keys = path.split("/");
+  const obj = {};
+  let ref = obj;
+  const lastIdx = keys.length - 1;
+  for (let i = 0; i <= lastIdx; i++) {
+    ref[keys[i]] = i === lastIdx ? value || {} : {};
+    ref = ref[keys[i]];
+  }
+  return obj;
+};
+const applyDependentState = (element, state) => {
+  const { __element } = state;
+  const origState = __element?.state;
+  if (!origState) return;
+  const dependentState = deepClone(origState, STATE_METHODS);
+  const newDepends = { [element.key]: dependentState };
+  const __depends = isObject(origState.__depends) ? { ...origState.__depends, ...newDepends } : newDepends;
+  if (Array.isArray(origState)) {
+    addProtoToArray(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  } else {
+    Object.setPrototypeOf(origState, {
+      ...Object.getPrototypeOf(origState),
+      __depends
+    });
+  }
+  return dependentState;
+};
+const overwriteState = (state, obj, options = {}) => {
+  const { overwrite } = options;
+  if (!overwrite) return;
+  const shallow = overwrite === "shallow";
+  const merge = overwrite === "merge";
+  if (merge) {
+    deepMerge(state, obj, STATE_METHODS);
+    return;
+  }
+  const overwriteFunc = shallow ? overwriteShallow : overwriteDeep;
+  overwriteFunc(state, obj, STATE_METHODS);
+};
+export {
+  applyDependentState,
+  checkForStateTypes,
+  checkIfInherits,
+  createInheritedState,
+  createNestedObjectByKeyPath,
+  findInheritedState,
+  getChildStateInKey,
+  getParentStateInKey,
+  getRootStateInKey,
+  isState,
+  overwriteState
+};

package/dist/esm/string-extra.js

@@ -0,0 +1,52 @@
+import { isString, isObject, isArray, isNumber } from "./types.js";
+const copyStringToClipboard = async (str) => {
+  try {
+    await navigator.clipboard.writeText(str);
+  } catch (err) {
+    console.warn("Failed to copy text: ", err);
+  }
+};
+const copyJavaScriptToClipboard = async (jsCode) => {
+  try {
+    const blob = new Blob([jsCode], { type: "text/javascript" });
+    const clipboardItem = new window.ClipboardItem({ "text/plain": blob });
+    await navigator.clipboard.write([clipboardItem]);
+    console.log("JavaScript code copied to clipboard as text/javascript");
+  } catch (err) {
+    console.error("Failed to copy JavaScript code: ", err);
+  }
+};
+const removeChars = (str) => {
+  return str.replace(/[^a-zA-Z0-9_]/g, "");
+};
+const toCamelCase = (str) => {
+  if (typeof str !== "string") str = String(str || "");
+  return str.replace(/(?:^\w|[A-Z]|\b\w)/g, function(word, index) {
+    return index === 0 ? word.toLowerCase() : word.toUpperCase();
+  }).replace(/\s+/g, "");
+};
+const toTitleCase = (str) => str && str.replace(/\w\S*/g, (txt) => {
+  return txt.charAt(0).toUpperCase() + txt.substr(1).toLowerCase();
+});
+const toDashCase = (val) => val.replace(/[^a-zA-Z0-9]/g, " ").trim().toLowerCase().replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+const toDescriptionCase = (str = "") => {
+  if (typeof str !== "string") return;
+  const result = str.replace(/([A-Z])/g, " $1");
+  return result.charAt(0).toUpperCase() + result.slice(1);
+};
+const arrayzeValue = (val) => {
+  if (isArray(val)) return val;
+  if (isString(val)) return val.split(" ");
+  if (isObject(val)) return Object.values(val);
+  if (isNumber(val)) return [val];
+};
+export {
+  arrayzeValue,
+  copyJavaScriptToClipboard,
+  copyStringToClipboard,
+  removeChars,
+  toCamelCase,
+  toDashCase,
+  toDescriptionCase,
+  toTitleCase
+};