@likec4/core 0.33.0 → 0.34.0

package/dist/compute-view/compute-predicates.mjs

@@ -1,324 +0,0 @@
-import { anyPass, both, either, isNil, uniq } from "rambdax";
-import * as Expr from "../types/expression.mjs";
-import { Relations, commonAncestor, isAncestor, isSameHierarchy } from "../utils/index.mjs";
-import { isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } from "../utils/relations.mjs";
-import { ComputeCtx } from "./compute-ctx.mjs";
-export const includeElementRef = (ctx, expr) => {
-  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
-  const filters = [];
-  if (expr.isDescedants) {
-    elements.forEach((child) => {
-      filters.push(both(Relations.isInside(expr.element), Relations.isAnyInOut(child.id)));
-    });
-  }
-  const ctxElements = uniq([...ctx.elements, ...ctx.implicits]);
-  const excludeImplicits = [];
-  for (const el of elements) {
-    if (ctx.root && ctx.root !== el.id && !isAncestor(el.id, ctx.root)) {
-      excludeImplicits.push(...[...ctx.implicits].filter((impl) => isAncestor(el.id, impl.id)));
-    }
-    for (const ctxEl of ctxElements) {
-      if (!isSameHierarchy(el, ctxEl)) {
-        filters.push(Relations.isAnyBetween(el.id, ctxEl.id));
-      }
-    }
-  }
-  const relations = filters.length ? ctx.index.filterRelations(anyPass(filters)) : [];
-  if (excludeImplicits.length == 0) {
-    return ctx.include({ elements, relations });
-  }
-  return ctx.include({ elements, relations }).exclude({ implicits: excludeImplicits });
-};
-export const excludeElementRef = (ctx, expr) => {
-  const elements = expr.isDescedants ? ctx.index.children(expr.element) : [ctx.index.find(expr.element)];
-  const elementsIds = elements.map((e) => e.id);
-  const relations = [...ctx.relations].filter(
-    (r) => elementsIds.includes(r.source) || elementsIds.includes(r.target)
-  );
-  return ctx.exclude({ elements, relations });
-};
-const asElementPredicate = (expr) => {
-  if (expr.isEqual) {
-    if (Expr.isElementKindExpr(expr)) {
-      return (e) => e.kind === expr.elementKind;
-    } else {
-      return ({ tags }) => !!tags && tags.includes(expr.elementTag);
-    }
-  } else {
-    if (Expr.isElementKindExpr(expr)) {
-      return (e) => e.kind !== expr.elementKind;
-    } else {
-      return ({ tags }) => isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    }
-  }
-};
-export const includeElementKindOrTag = (ctx, expr) => {
-  const elements = ctx.index.elements.filter(asElementPredicate(expr));
-  return elements.reduce(
-    (accCtx, el) => includeElementRef(accCtx, {
-      element: el.id,
-      isDescedants: false
-    }),
-    ctx
-  );
-};
-export const excludeElementKindOrTag = (ctx, expr) => {
-  const predicate = asElementPredicate(expr);
-  const elements = [...ctx.elements].filter(predicate);
-  const implicits = [...ctx.implicits].filter(predicate);
-  return ctx.exclude({ elements, implicits });
-};
-export const includeWildcardRef = (ctx, _expr) => {
-  const { root } = ctx;
-  if (root) {
-    const elements = [ctx.index.find(root), ...ctx.index.children(root)];
-    const allImplicits = [
-      ...ctx.index.siblings(root),
-      ...ctx.index.ancestors(root).flatMap((a) => [...ctx.index.siblings(a.id)])
-    ];
-    const inOut = ctx.index.filterRelations(isAnyInOut(root));
-    const implicits = [];
-    for (const implicit of allImplicits) {
-      if (inOut.some(isAnyInOut(implicit.id))) {
-        implicits.push(implicit);
-      }
-    }
-    return ctx.include({
-      elements,
-      relations: [...ctx.index.filterRelations(isInside(root)), ...inOut],
-      implicits
-    });
-  } else {
-    const elements = ctx.index.rootElements();
-    if (elements.length <= 1) {
-      return new ComputeCtx(ctx.index, ctx.root, new Set(elements));
-    }
-    const relations = ctx.index.filterRelations(
-      (rel) => isNil(commonAncestor(rel.source, rel.target))
-    );
-    return ctx.include({
-      elements,
-      relations
-    });
-  }
-};
-export const excludeWildcardRef = (ctx, _expr) => {
-  const { root } = ctx;
-  if (root) {
-    const relations = [...ctx.relations].filter(either(isInside(root), isAnyInOut(root)));
-    return ctx.exclude({
-      elements: [...ctx.elements].filter((e) => e.id === root || isAncestor(root, e.id)),
-      relations,
-      implicits: [...ctx.implicits].filter((e) => relations.some(isAnyInOut(e.id)))
-    });
-  } else {
-    return new ComputeCtx(ctx.index, ctx.root);
-  }
-};
-const resolveElements = (ctx, expr) => {
-  if (Expr.isWildcard(expr)) {
-    if (ctx.root) {
-      return [ctx.index.find(ctx.root)];
-    } else {
-      return ctx.index.rootElements();
-    }
-  }
-  if (Expr.isElementKindExpr(expr)) {
-    return ctx.index.elements.filter((el) => {
-      if (expr.isEqual) {
-        return el.kind === expr.elementKind;
-      }
-      return el.kind !== expr.elementKind;
-    });
-  }
-  if (Expr.isElementTagExpr(expr)) {
-    return ctx.index.elements.filter((el) => {
-      const tags = el.tags;
-      if (expr.isEqual) {
-        return !!tags && tags.includes(expr.elementTag);
-      }
-      return isNil(tags) || tags.length === 0 || !tags.includes(expr.elementTag);
-    });
-  }
-  if (expr.isDescedants) {
-    return ctx.index.children(expr.element);
-  } else {
-    return [ctx.index.find(expr.element)];
-  }
-};
-export const includeIncomingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.incoming)) {
-    allrelations = allrelations.filter(isIncoming(expr.incoming.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isIncoming(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeIncomingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.incoming) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.incoming);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isIncomings = anyPass(elements.map((el) => isIncoming(el.id)));
-  const excluded = [...ctx.relations].filter(isIncomings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeOutgoingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.outgoing)) {
-    allrelations = allrelations.filter(isOutgoing(expr.outgoing.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const el of elements) {
-    const elRelations = allrelations.filter(isOutgoing(el.id));
-    if (elRelations.length > 0) {
-      relations.push(...elRelations);
-      implicits.push(el);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeOutgoingExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.outgoing) && !ctx.root) {
-    return ctx;
-  }
-  const elements = resolveElements(ctx, expr.outgoing);
-  if (elements.length === 0) {
-    return ctx;
-  }
-  const isOutgoings = anyPass(elements.map((el) => isOutgoing(el.id)));
-  const excluded = [...ctx.relations].filter(isOutgoings);
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeInOutExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  let allrelations = ctx.index.relations;
-  if (Expr.isElementRef(expr.inout)) {
-    allrelations = allrelations.filter(isAnyInOut(expr.inout.element));
-  }
-  const implicits = [];
-  const relations = [];
-  for (const target of targets) {
-    const foundRelations = allrelations.filter(isAnyInOut(target.id));
-    if (foundRelations.length > 0) {
-      relations.push(...foundRelations);
-      implicits.push(target);
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeInOutExpr = (ctx, expr) => {
-  if (Expr.isWildcard(expr.inout) && !ctx.root) {
-    return ctx;
-  }
-  const targets = resolveElements(ctx, expr.inout);
-  if (targets.length === 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter(anyPass(targets.map((t) => isAnyInOut(t.id))));
-  if (excluded.length > 0) {
-    return ctx.exclude({
-      relations: excluded
-    });
-  }
-  return ctx;
-};
-export const includeRelationExpr = (ctx, expr) => {
-  const sources = resolveElements(ctx, expr.source);
-  const targets = resolveElements(ctx, expr.target);
-  if (sources.length === 0 || targets.length === 0) {
-    return ctx;
-  }
-  const implicits = [];
-  const relations = [];
-  for (const source of sources) {
-    for (const target of targets) {
-      if (isSameHierarchy(source, target)) {
-        continue;
-      }
-      const foundRelations = ctx.index.filterRelations(isBetween(source.id, target.id));
-      if (foundRelations.length > 0) {
-        relations.push(...foundRelations);
-        implicits.push(source, target);
-      }
-    }
-  }
-  return ctx.include({
-    relations,
-    implicits
-  });
-};
-export const excludeRelationExpr = (ctx, expr) => {
-  const sources = resolveElements(ctx, expr.source);
-  const targets = resolveElements(ctx, expr.target);
-  const filters = [];
-  for (const source of sources) {
-    for (const target of targets) {
-      if (isSameHierarchy(source, target)) {
-        continue;
-      }
-      filters.push(isBetween(source.id, target.id));
-    }
-  }
-  if (filters.length == 0) {
-    return ctx;
-  }
-  const excluded = [...ctx.relations].filter(anyPass(filters));
-  if (excluded.length == 0) {
-    return ctx;
-  }
-  return ctx.exclude({
-    relations: excluded
-  });
-};

package/dist/compute-view/compute.mjs

@@ -1,39 +0,0 @@
-import { compact, find, map, mapToObj } from "remeda";
-import { ModelIndex } from "../model-index/index.mjs";
-import { computeElementView } from "./compute-element-view.mjs";
-export function computeView(view, index) {
-  try {
-    return computeElementView(view, index);
-  } catch (e) {
-    console.error(e);
-    return null;
-  }
-}
-export function computeViews(model) {
-  const index = ModelIndex.from(model);
-  const computedViews = compact(map(model.views, (view) => computeView(view, index)));
-  return {
-    elements: model.elements,
-    relations: model.relations,
-    views: mapToObj(computedViews, (view) => [view.id, view])
-  };
-}
-export function assignNavigateTo(views) {
-  const allElementViews = /* @__PURE__ */ new Map();
-  for (const { id, viewOf } of views) {
-    if (viewOf) {
-      const viewsOf = allElementViews.get(viewOf) ?? [];
-      viewsOf.push(id);
-      allElementViews.set(viewOf, viewsOf);
-    }
-  }
-  for (const { id, nodes } of views) {
-    for (const node of nodes) {
-      const navigateTo = find(allElementViews.get(node.id) ?? [], (v) => v !== id);
-      if (navigateTo) {
-        node.navigateTo = navigateTo;
-      }
-    }
-  }
-  return views;
-}

package/dist/compute-view/index.mjs

@@ -1 +0,0 @@
-export { computeView, computeViews, assignNavigateTo } from "./compute.mjs";

package/dist/compute-view/utils/anyPossibleRelations.mjs

@@ -1,12 +0,0 @@
-import { prop, uniqBy } from "rambdax";
-import { compareByFqnHierarchically, isAncestor } from "../../utils/fqn.mjs";
-export function* anyPossibleRelations(elements) {
-  const uniqElements = uniqBy(prop("id"), elements).sort(compareByFqnHierarchically).reverse();
-  for (const source of uniqElements) {
-    for (const target of uniqElements) {
-      if (source !== target && !isAncestor(source, target) && !isAncestor(target, source)) {
-        yield [source, target];
-      }
-    }
-  }
-}

package/dist/compute-view/utils/applyViewRuleStyles.mjs

@@ -1,50 +0,0 @@
-import { anyPass, filter, clone, isNil } from "rambdax";
-import { isDefined } from "remeda";
-import * as Expr from "../../types/expression.mjs";
-import { nonexhaustive } from "../../errors/index.mjs";
-export function applyViewRuleStyles(rules, _nodes) {
-  if (rules.length === 0) {
-    return _nodes;
-  }
-  const nodes = clone(_nodes);
-  for (const rule of rules) {
-    const predicates = [];
-    if (!rule.style.color && !rule.style.shape) {
-      continue;
-    }
-    for (const target of rule.targets) {
-      if (Expr.isWildcard(target)) {
-        predicates.push(() => true);
-        break;
-      }
-      if (Expr.isElementKindExpr(target)) {
-        predicates.push(
-          target.isEqual ? (n) => n.kind === target.elementKind : (n) => n.kind !== target.elementKind
-        );
-        continue;
-      }
-      if (Expr.isElementTagExpr(target)) {
-        predicates.push(
-          target.isEqual ? ({ tags }) => !!tags && tags.includes(target.elementTag) : ({ tags }) => isNil(tags) || !tags.includes(target.elementTag)
-        );
-        continue;
-      }
-      if (Expr.isElementRef(target)) {
-        const { element, isDescedants } = target;
-        predicates.push(
-          isDescedants ? (n) => n.id.startsWith(element + ".") : (n) => n.id === element
-        );
-        continue;
-      }
-      nonexhaustive(target);
-    }
-    filter(anyPass(predicates), nodes).forEach((n) => {
-      n.shape = rule.style.shape ?? n.shape;
-      n.color = rule.style.color ?? n.color;
-      if (isDefined.strict(rule.style.icon)) {
-        n.icon = rule.style.icon;
-      }
-    });
-  }
-  return nodes;
-}

package/dist/errors/_base.mjs

@@ -1,4 +0,0 @@
-import ModernError from "modern-errors";
-export const BaseError = ModernError.subclass("BaseError");
-export const UnknownError = BaseError.subclass("UnknownError");
-export const RelationRefError = BaseError.subclass("RelationRefError");

package/dist/errors/index.mjs

@@ -1,5 +0,0 @@
-export * from "./_base.mjs";
-export * from "./invariant.mjs";
-export * from "./non-nullable.mjs";
-export * from "./nonexhaustive.mjs";
-export * from "./model-index.mjs";

package/dist/errors/invariant.mjs

@@ -1,8 +0,0 @@
-import { BaseError } from "./_base.mjs";
-export const InvariantError = BaseError.subclass("InvariantError");
-export function invariant(condition, message) {
-  if (condition) {
-    return;
-  }
-  throw new InvariantError(message ?? "Invariant failed");
-}

package/dist/errors/model-index.mjs

@@ -1,8 +0,0 @@
-import { BaseError } from "./_base.mjs";
-export const InvalidModelError = BaseError.subclass("InvalidModelError");
-export function ensureModel(condition, message) {
-  if (condition) {
-    return;
-  }
-  throw new InvalidModelError(message ?? "ModelIndex Invariant failed");
-}

package/dist/errors/non-nullable.mjs

@@ -1,8 +0,0 @@
-import { BaseError } from "./_base.mjs";
-export const UnexpectedNullableError = BaseError.subclass("UnexpectedNullableError");
-export function nonNullable(value) {
-  if (value == null) {
-    throw new UnexpectedNullableError("Expected value to not be null or undefined");
-  }
-  return value;
-}

package/dist/errors/nonexhaustive.mjs

@@ -1,5 +0,0 @@
-import { BaseError } from "./_base.mjs";
-export const NonExhaustiveError = BaseError.subclass("NonExhaustiveError");
-export function nonexhaustive(arg) {
-  throw new NonExhaustiveError(`NonExhaustive value: ${JSON.stringify(arg)}`);
-}

package/dist/index.mjs

@@ -1,6 +0,0 @@
-export * from "./types/index.mjs";
-export * from "./utils/index.mjs";
-export * from "./model-index/index.mjs";
-export * from "./compute-view/index.mjs";
-export * from "./colors.mjs";
-export * from "./errors/index.mjs";

package/dist/model-index/index.mjs

@@ -1 +0,0 @@
-export { default as ModelIndex } from "./ModelIndex.mjs";

package/dist/types/element.mjs

@@ -1,5 +0,0 @@
-export function AsFqn(name, parent) {
-  return parent ? parent + "." + name : name;
-}
-export const DefaultThemeColor = "primary";
-export const DefaultElementShape = "rectangle";

package/dist/types/expression.mjs

@@ -1,30 +0,0 @@
-export function isElementRef(expr) {
-  return "element" in expr && "isDescedants" in expr;
-}
-export function isWildcard(expr) {
-  return "wildcard" in expr;
-}
-export function isElementKindExpr(expr) {
-  return "elementKind" in expr && "isEqual" in expr;
-}
-export function isElementTagExpr(expr) {
-  return "elementTag" in expr && "isEqual" in expr;
-}
-export function isElement(expr) {
-  return isElementRef(expr) || isWildcard(expr) || isElementKindExpr(expr) || isElementTagExpr(expr);
-}
-export function isRelation(expr) {
-  return "source" in expr && "target" in expr;
-}
-export function isInOut(expr) {
-  return "inout" in expr;
-}
-export function isIncoming(expr) {
-  return "incoming" in expr;
-}
-export function isOutgoing(expr) {
-  return "outgoing" in expr;
-}
-export function isAnyRelation(expr) {
-  return isRelation(expr) || isInOut(expr) || isIncoming(expr) || isOutgoing(expr);
-}

package/dist/types/index.mjs

@@ -1,3 +0,0 @@
-export { AsFqn, DefaultThemeColor, DefaultElementShape } from "./element.mjs";
-export { isViewRuleExpression, isViewRuleAutoLayout, isViewRuleStyle } from "./view.mjs";
-export * as Expr from "./expression.mjs";

package/dist/types/view.mjs

@@ -1,9 +0,0 @@
-export function isViewRuleExpression(rule) {
-  return "exprs" in rule && "isInclude" in rule;
-}
-export function isViewRuleStyle(rule) {
-  return "style" in rule && "targets" in rule;
-}
-export function isViewRuleAutoLayout(rule) {
-  return "autoLayout" in rule;
-}

package/dist/utils/compute-node-levels.mjs

@@ -1,31 +0,0 @@
-import { invariant } from "../errors/index.mjs";
-export const computeNodeLevels = ({ nodes }) => {
-  const nodeLevels = {};
-  const compute = (node, level) => {
-    let levels = nodeLevels[node.id];
-    if (levels) {
-      return levels;
-    }
-    if (node.children.length === 0) {
-      levels = { level, depth: 0 };
-      nodeLevels[node.id] = levels;
-      return levels;
-    }
-    let depth = 1;
-    for (const childId of node.children) {
-      const child = nodes.find((n) => n.id === childId);
-      invariant(child, `Child ${childId} not found`);
-      const { depth: childDepth } = compute(child, level + 1);
-      depth = Math.max(childDepth + 1, depth);
-    }
-    levels = { level, depth };
-    nodeLevels[node.id] = levels;
-    return levels;
-  };
-  for (const node of nodes) {
-    if (!node.parent) {
-      compute(node, 0);
-    }
-  }
-  return nodeLevels;
-};

package/dist/utils/fqn.mjs

@@ -1,66 +0,0 @@
-import { anyPass } from "remeda";
-import { isString } from "./guards.mjs";
-export function nameFromFqn(fqn) {
-  const lastDot = fqn.lastIndexOf(".");
-  if (lastDot > 0) {
-    return fqn.slice(lastDot + 1);
-  } else {
-    return fqn;
-  }
-}
-export function isAncestor(...args) {
-  const ancestor = isString(args[0]) ? args[0] : args[0].id;
-  const another = isString(args[1]) ? args[1] : args[1].id;
-  return another.startsWith(ancestor + ".");
-}
-export function isSameHierarchy(...args) {
-  const one = isString(args[0]) ? args[0] : args[0].id;
-  const another = isString(args[1]) ? args[1] : args[1].id;
-  return one === another || another.startsWith(one + ".") || one.startsWith(another + ".");
-}
-export function isDescendantOf(ancestors) {
-  const predicates = ancestors.flatMap((a) => [(e) => e.id === a.id, (e) => isAncestor(a, e)]);
-  return anyPass(predicates);
-}
-export function notDescendantOf(ancestors) {
-  const isDescendant = isDescendantOf(ancestors);
-  return (e) => !isDescendant(e);
-}
-export function commonAncestor(first, second) {
-  const parentA = parentFqn(first);
-  const parentB = parentFqn(second);
-  if (parentA === parentB) {
-    return parentA;
-  }
-  if (!parentA || !parentB) {
-    return null;
-  }
-  const a = first.split(".");
-  const b = second.split(".");
-  let ancestor = null;
-  while (a.length > 1 && b.length > 1 && !!a[0] && a[0] === b[0]) {
-    ancestor = ancestor ? `${ancestor}.${a[0]}` : a[0];
-    a.shift();
-    b.shift();
-  }
-  return ancestor;
-}
-export function parentFqn(fqn) {
-  const lastDot = fqn.lastIndexOf(".");
-  if (lastDot > 0) {
-    return fqn.substring(0, lastDot);
-  }
-  return null;
-}
-export function compareFqnHierarchically(a, b) {
-  const depthA = a.split(".").length;
-  const depthB = b.split(".").length;
-  if (depthA === depthB) {
-    return 0;
-  } else {
-    return depthA - depthB;
-  }
-}
-export function compareByFqnHierarchically(a, b) {
-  return compareFqnHierarchically(a.id, b.id);
-}

package/dist/utils/guards.mjs

@@ -1,13 +0,0 @@
-import { NonExhaustiveError } from "../errors/nonexhaustive.mjs";
-export function isString(value) {
-  return typeof value === "string";
-}
-export function failUnexpected(arg) {
-  throw new NonExhaustiveError(`Unexpected value: ${JSON.stringify(arg)}`);
-}
-export function ignoreNeverInRuntime(arg) {
-  console.warn(`Unexpected and ignored value: ${JSON.stringify(arg)}`);
-}
-export function isNonEmptyArray(arr) {
-  return arr.length > 0;
-}

package/dist/utils/index.mjs

@@ -1,4 +0,0 @@
-export * from "./fqn.mjs";
-export * from "./guards.mjs";
-export * from "./compute-node-levels.mjs";
-export * as Relations from "./relations.mjs";