@vc-shell/framework 1.1.1 → 1.1.2

package/dist/assets/core-services-CAfJRsjs.js

@@ -0,0 +1,4 @@
+import './core-composables-DYxpIWyY.js';
+import 'vue';
+import './ui-navigation-BtHa6ovW.js';
+import './ui-app-D31Pr1WY.js';

package/dist/assets/core-utilities-BTktq_a-.js

@@ -0,0 +1,33 @@
+function camelToSnake(str) {
+  return str.replace(/[\w]([A-Z])/g, function(m) {
+    return m[0] + "_" + m[1];
+  }).toLowerCase();
+}
+
+const kebabToCamel = (str) => str.replace(/-./g, (x) => x[1].toUpperCase());
+function kebabToPascal(str) {
+  const camelCase = kebabToCamel(str);
+  const pascalCase = camelCase[0].toUpperCase() + camelCase.substring(1);
+  return pascalCase;
+}
+
+function camelize(str) {
+  return str.replace(/\W+(.)/g, function(match, chr) {
+    return chr.toUpperCase();
+  });
+}
+
+function generateId() {
+  return Math.random().toString(36).substring(2, 9);
+}
+
+const coreUtilities = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  camelToSnake,
+  camelize,
+  generateId,
+  kebabToCamel,
+  kebabToPascal
+}, Symbol.toStringTag, { value: 'Module' }));
+
+export { camelToSnake as a, kebabToCamel as b, coreUtilities as c, camelize as d, generateId as g, kebabToPascal as k };

package/dist/assets/crystal--rIRMl16.js

@@ -0,0 +1,419 @@
+function wordRegExp(words, end) {
+  return new RegExp((end ? "" : "^") + "(?:" + words.join("|") + ")" + (end ? "$" : "\\b"));
+}
+
+function chain(tokenize, stream, state) {
+  state.tokenize.push(tokenize);
+  return tokenize(stream, state);
+}
+
+var operators = /^(?:[-+/%|&^]|\*\*?|[<>]{2})/;
+var conditionalOperators = /^(?:[=!]~|===|<=>|[<>=!]=?|[|&]{2}|~)/;
+var indexingOperators = /^(?:\[\][?=]?)/;
+var anotherOperators = /^(?:\.(?:\.{2})?|->|[?:])/;
+var idents = /^[a-z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
+var types = /^[A-Z_\u009F-\uFFFF][a-zA-Z0-9_\u009F-\uFFFF]*/;
+var keywords = wordRegExp([
+  "abstract", "alias", "as", "asm", "begin", "break", "case", "class", "def", "do",
+  "else", "elsif", "end", "ensure", "enum", "extend", "for", "fun", "if",
+  "include", "instance_sizeof", "lib", "macro", "module", "next", "of", "out", "pointerof",
+  "private", "protected", "rescue", "return", "require", "select", "sizeof", "struct",
+  "super", "then", "type", "typeof", "uninitialized", "union", "unless", "until", "when", "while", "with",
+  "yield", "__DIR__", "__END_LINE__", "__FILE__", "__LINE__"
+]);
+var atomWords = wordRegExp(["true", "false", "nil", "self"]);
+var indentKeywordsArray = [
+  "def", "fun", "macro",
+  "class", "module", "struct", "lib", "enum", "union",
+  "do", "for"
+];
+var indentKeywords = wordRegExp(indentKeywordsArray);
+var indentExpressionKeywordsArray = ["if", "unless", "case", "while", "until", "begin", "then"];
+var indentExpressionKeywords = wordRegExp(indentExpressionKeywordsArray);
+var dedentKeywordsArray = ["end", "else", "elsif", "rescue", "ensure"];
+var dedentKeywords = wordRegExp(dedentKeywordsArray);
+var dedentPunctualsArray = ["\\)", "\\}", "\\]"];
+var dedentPunctuals = new RegExp("^(?:" + dedentPunctualsArray.join("|") + ")$");
+var nextTokenizer = {
+  "def": tokenFollowIdent, "fun": tokenFollowIdent, "macro": tokenMacroDef,
+  "class": tokenFollowType, "module": tokenFollowType, "struct": tokenFollowType,
+  "lib": tokenFollowType, "enum": tokenFollowType, "union": tokenFollowType
+};
+var matching = {"[": "]", "{": "}", "(": ")", "<": ">"};
+
+function tokenBase(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+
+  // Macros
+  if (state.lastToken != "\\" && stream.match("{%", false)) {
+    return chain(tokenMacro("%", "%"), stream, state);
+  }
+
+  if (state.lastToken != "\\" && stream.match("{{", false)) {
+    return chain(tokenMacro("{", "}"), stream, state);
+  }
+
+  // Comments
+  if (stream.peek() == "#") {
+    stream.skipToEnd();
+    return "comment";
+  }
+
+  // Variables and keywords
+  var matched;
+  if (stream.match(idents)) {
+    stream.eat(/[?!]/);
+
+    matched = stream.current();
+    if (stream.eat(":")) {
+      return "atom";
+    } else if (state.lastToken == ".") {
+      return "property";
+    } else if (keywords.test(matched)) {
+      if (indentKeywords.test(matched)) {
+        if (!(matched == "fun" && state.blocks.indexOf("lib") >= 0) && !(matched == "def" && state.lastToken == "abstract")) {
+          state.blocks.push(matched);
+          state.currentIndent += 1;
+        }
+      } else if ((state.lastStyle == "operator" || !state.lastStyle) && indentExpressionKeywords.test(matched)) {
+        state.blocks.push(matched);
+        state.currentIndent += 1;
+      } else if (matched == "end") {
+        state.blocks.pop();
+        state.currentIndent -= 1;
+      }
+
+      if (nextTokenizer.hasOwnProperty(matched)) {
+        state.tokenize.push(nextTokenizer[matched]);
+      }
+
+      return "keyword";
+    } else if (atomWords.test(matched)) {
+      return "atom";
+    }
+
+    return "variable";
+  }
+
+  // Class variables and instance variables
+  // or attributes
+  if (stream.eat("@")) {
+    if (stream.peek() == "[") {
+      return chain(tokenNest("[", "]", "meta"), stream, state);
+    }
+
+    stream.eat("@");
+    stream.match(idents) || stream.match(types);
+    return "propertyName";
+  }
+
+  // Constants and types
+  if (stream.match(types)) {
+    return "tag";
+  }
+
+  // Symbols or ':' operator
+  if (stream.eat(":")) {
+    if (stream.eat("\"")) {
+      return chain(tokenQuote("\"", "atom", false), stream, state);
+    } else if (stream.match(idents) || stream.match(types) ||
+               stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators)) {
+      return "atom";
+    }
+    stream.eat(":");
+    return "operator";
+  }
+
+  // Strings
+  if (stream.eat("\"")) {
+    return chain(tokenQuote("\"", "string", true), stream, state);
+  }
+
+  // Strings or regexps or macro variables or '%' operator
+  if (stream.peek() == "%") {
+    var style = "string";
+    var embed = true;
+    var delim;
+
+    if (stream.match("%r")) {
+      // Regexps
+      style = "string.special";
+      delim = stream.next();
+    } else if (stream.match("%w")) {
+      embed = false;
+      delim = stream.next();
+    } else if (stream.match("%q")) {
+      embed = false;
+      delim = stream.next();
+    } else {
+      if(delim = stream.match(/^%([^\w\s=])/)) {
+        delim = delim[1];
+      } else if (stream.match(/^%[a-zA-Z_\u009F-\uFFFF][\w\u009F-\uFFFF]*/)) {
+        // Macro variables
+        return "meta";
+      } else if (stream.eat('%')) {
+        // '%' operator
+        return "operator";
+      }
+    }
+
+    if (matching.hasOwnProperty(delim)) {
+      delim = matching[delim];
+    }
+    return chain(tokenQuote(delim, style, embed), stream, state);
+  }
+
+  // Here Docs
+  if (matched = stream.match(/^<<-('?)([A-Z]\w*)\1/)) {
+    return chain(tokenHereDoc(matched[2], !matched[1]), stream, state)
+  }
+
+  // Characters
+  if (stream.eat("'")) {
+    stream.match(/^(?:[^']|\\(?:[befnrtv0'"]|[0-7]{3}|u(?:[0-9a-fA-F]{4}|\{[0-9a-fA-F]{1,6}\})))/);
+    stream.eat("'");
+    return "atom";
+  }
+
+  // Numbers
+  if (stream.eat("0")) {
+    if (stream.eat("x")) {
+      stream.match(/^[0-9a-fA-F_]+/);
+    } else if (stream.eat("o")) {
+      stream.match(/^[0-7_]+/);
+    } else if (stream.eat("b")) {
+      stream.match(/^[01_]+/);
+    }
+    return "number";
+  }
+
+  if (stream.eat(/^\d/)) {
+    stream.match(/^[\d_]*(?:\.[\d_]+)?(?:[eE][+-]?\d+)?/);
+    return "number";
+  }
+
+  // Operators
+  if (stream.match(operators)) {
+    stream.eat("="); // Operators can follow assign symbol.
+    return "operator";
+  }
+
+  if (stream.match(conditionalOperators) || stream.match(anotherOperators)) {
+    return "operator";
+  }
+
+  // Parens and braces
+  if (matched = stream.match(/[({[]/, false)) {
+    matched = matched[0];
+    return chain(tokenNest(matched, matching[matched], null), stream, state);
+  }
+
+  // Escapes
+  if (stream.eat("\\")) {
+    stream.next();
+    return "meta";
+  }
+
+  stream.next();
+  return null;
+}
+
+function tokenNest(begin, end, style, started) {
+  return function (stream, state) {
+    if (!started && stream.match(begin)) {
+      state.tokenize[state.tokenize.length - 1] = tokenNest(begin, end, style, true);
+      state.currentIndent += 1;
+      return style;
+    }
+
+    var nextStyle = tokenBase(stream, state);
+    if (stream.current() === end) {
+      state.tokenize.pop();
+      state.currentIndent -= 1;
+      nextStyle = style;
+    }
+
+    return nextStyle;
+  };
+}
+
+function tokenMacro(begin, end, started) {
+  return function (stream, state) {
+    if (!started && stream.match("{" + begin)) {
+      state.currentIndent += 1;
+      state.tokenize[state.tokenize.length - 1] = tokenMacro(begin, end, true);
+      return "meta";
+    }
+
+    if (stream.match(end + "}")) {
+      state.currentIndent -= 1;
+      state.tokenize.pop();
+      return "meta";
+    }
+
+    return tokenBase(stream, state);
+  };
+}
+
+function tokenMacroDef(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+
+  var matched;
+  if (matched = stream.match(idents)) {
+    if (matched == "def") {
+      return "keyword";
+    }
+    stream.eat(/[?!]/);
+  }
+
+  state.tokenize.pop();
+  return "def";
+}
+
+function tokenFollowIdent(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+
+  if (stream.match(idents)) {
+    stream.eat(/[!?]/);
+  } else {
+    stream.match(operators) || stream.match(conditionalOperators) || stream.match(indexingOperators);
+  }
+  state.tokenize.pop();
+  return "def";
+}
+
+function tokenFollowType(stream, state) {
+  if (stream.eatSpace()) {
+    return null;
+  }
+
+  stream.match(types);
+  state.tokenize.pop();
+  return "def";
+}
+
+function tokenQuote(end, style, embed) {
+  return function (stream, state) {
+    var escaped = false;
+
+    while (stream.peek()) {
+      if (!escaped) {
+        if (stream.match("{%", false)) {
+          state.tokenize.push(tokenMacro("%", "%"));
+          return style;
+        }
+
+        if (stream.match("{{", false)) {
+          state.tokenize.push(tokenMacro("{", "}"));
+          return style;
+        }
+
+        if (embed && stream.match("#{", false)) {
+          state.tokenize.push(tokenNest("#{", "}", "meta"));
+          return style;
+        }
+
+        var ch = stream.next();
+
+        if (ch == end) {
+          state.tokenize.pop();
+          return style;
+        }
+
+        escaped = embed && ch == "\\";
+      } else {
+        stream.next();
+        escaped = false;
+      }
+    }
+
+    return style;
+  };
+}
+
+function tokenHereDoc(phrase, embed) {
+  return function (stream, state) {
+    if (stream.sol()) {
+      stream.eatSpace();
+      if (stream.match(phrase)) {
+        state.tokenize.pop();
+        return "string";
+      }
+    }
+
+    var escaped = false;
+    while (stream.peek()) {
+      if (!escaped) {
+        if (stream.match("{%", false)) {
+          state.tokenize.push(tokenMacro("%", "%"));
+          return "string";
+        }
+
+        if (stream.match("{{", false)) {
+          state.tokenize.push(tokenMacro("{", "}"));
+          return "string";
+        }
+
+        if (embed && stream.match("#{", false)) {
+          state.tokenize.push(tokenNest("#{", "}", "meta"));
+          return "string";
+        }
+
+        escaped = stream.next() == "\\" && embed;
+      } else {
+        stream.next();
+        escaped = false;
+      }
+    }
+
+    return "string";
+  }
+}
+
+const crystal = {
+  name: "crystal",
+  startState: function () {
+    return {
+      tokenize: [tokenBase],
+      currentIndent: 0,
+      lastToken: null,
+      lastStyle: null,
+      blocks: []
+    };
+  },
+
+  token: function (stream, state) {
+    var style = state.tokenize[state.tokenize.length - 1](stream, state);
+    var token = stream.current();
+
+    if (style && style != "comment") {
+      state.lastToken = token;
+      state.lastStyle = style;
+    }
+
+    return style;
+  },
+
+  indent: function (state, textAfter, cx) {
+    textAfter = textAfter.replace(/^\s*(?:\{%)?\s*|\s*(?:%\})?\s*$/g, "");
+
+    if (dedentKeywords.test(textAfter) || dedentPunctuals.test(textAfter)) {
+      return cx.unit * (state.currentIndent - 1);
+    }
+
+    return cx.unit * state.currentIndent;
+  },
+
+  languageData: {
+    indentOnInput: wordRegExp(dedentPunctualsArray.concat(dedentKeywordsArray), true),
+    commentTokens: {line: "#"}
+  }
+};
+
+export { crystal };

package/dist/assets/css/core-directives-FL4vIIkN.css

@@ -0,0 +1,73 @@
+:root {
+  --v-loading-bg-color: var(--additional-50);
+  --v-loading-bg: rgb(from var(--v-loading-bg-color) r g b / 75%);
+  --v-loading-spinner-color: var(--primary-500, #319ed4);
+  --v-loading-spinner-size-small: 20px;
+  --v-loading-spinner-size-medium: 30px;
+  --v-loading-spinner-size-large: 40px;
+}
+
+.v-loading {
+  position: relative;
+  cursor: wait;
+}
+
+.v-loading::before {
+  content: "";
+  position: absolute;
+  z-index: var(--v-loading-z-index, 9998);
+  top: 0;
+  right: 0;
+  bottom: 0;
+  left: 0;
+  background-color: var(--v-loading-bg);
+  -webkit-backdrop-filter: blur(3px);
+          backdrop-filter: blur(3px);
+}
+
+.v-loading--no-blur::before {
+  -webkit-backdrop-filter: none;
+          backdrop-filter: none;
+}
+
+.v-loading--fullscreen {
+  position: fixed;
+  inset: 0;
+}
+
+.v-loading::after {
+  content: "";
+  position: absolute;
+  z-index: calc(var(--v-loading-z-index, 9999) + 1);
+  width: var(--v-loading-spinner-size, var(--v-loading-spinner-size-medium));
+  height: var(--v-loading-spinner-size, var(--v-loading-spinner-size-medium));
+  border: 4px solid var(--v-loading-spinner-color);
+  border-right-color: transparent;
+  animation: 0.75s linear infinite v-loading;
+  border-radius: 50%;
+  top: calc(50% - var(--v-loading-spinner-size, var(--v-loading-spinner-size-medium)) / 2);
+  left: calc(50% - var(--v-loading-spinner-size, var(--v-loading-spinner-size-medium)) / 2);
+  display: inline-block;
+}
+
+/* Размеры спиннера */
+.v-loading[data-loading-size="small"]::after {
+  --v-loading-spinner-size: var(--v-loading-spinner-size-small);
+  border-width: 2px;
+}
+
+.v-loading[data-loading-size="medium"]::after {
+  --v-loading-spinner-size: var(--v-loading-spinner-size-medium);
+  border-width: 3px;
+}
+
+.v-loading[data-loading-size="large"]::after {
+  --v-loading-spinner-size: var(--v-loading-spinner-size-large);
+  border-width: 4px;
+}
+
+@keyframes v-loading {
+  to {
+    transform: rotate(360deg);
+  }
+}