@likec4/core 1.1.1 → 1.2.1

package/src/utils/fqn.spec.ts

@@ -0,0 +1,105 @@
+import { describe, expect, it } from 'vitest'
+import type { Element, Fqn } from '../types'
+import {
+  ancestorsFqn,
+  commonAncestor,
+  compareFqnHierarchically,
+  isAncestor,
+  isDescendantOf,
+  notDescendantOf,
+  parentFqn
+} from './fqn'
+
+const el = (id: string): Element => ({ id }) as unknown as Element
+
+describe('parentFqn', () => {
+  it('should return null if no parent', () => {
+    expect(parentFqn('a' as Fqn)).toBeNull()
+  })
+  it('should return parent', () => {
+    expect(parentFqn('a.b' as Fqn)).toBe('a')
+    expect(parentFqn('a.b.c' as Fqn)).toBe('a.b')
+  })
+})
+
+describe('ancestorsFqn', () => {
+  it('should return empty array if no parent', () => {
+    expect(ancestorsFqn('a' as Fqn)).toEqual([])
+  })
+  it('should return ancestors', () => {
+    expect(ancestorsFqn('a.b.c.d.e' as Fqn)).toEqual(['a.b.c.d', 'a.b.c', 'a.b', 'a'])
+  })
+})
+
+describe('commonAncestor', () => {
+  it('should return null if no common ancestor', () => {
+    expect(commonAncestor('a' as Fqn, 'b' as Fqn)).toBeNull()
+    expect(commonAncestor('a.b' as Fqn, 'c.d' as Fqn)).toBeNull()
+  })
+
+  it('should return common ancestor', () => {
+    expect(commonAncestor('a.b' as Fqn, 'a.c' as Fqn)).toBe('a')
+    expect(commonAncestor('a.b.c' as Fqn, 'a.b.e' as Fqn)).toBe('a.b')
+    expect(commonAncestor('a.b.c.d.e' as Fqn, 'a.b.c.d' as Fqn)).toBe('a.b.c')
+  })
+})
+
+describe('isAncestor', () => {
+  it('should return true if ancestor', () => {
+    expect(isAncestor('a' as Fqn, 'a.b' as Fqn)).toBe(true)
+    expect(isAncestor('a.b' as Fqn, 'a.b.c' as Fqn)).toBe(true)
+  })
+  it('should return false if not ancestor', () => {
+    expect(isAncestor('a' as Fqn, 'b' as Fqn)).toBe(false)
+    expect(isAncestor('a.b' as Fqn, 'a' as Fqn)).toBe(false)
+    expect(isAncestor('a.b' as Fqn, 'b.a' as Fqn)).toBe(false)
+  })
+})
+
+describe('isDescendantOf', () => {
+  const predicate = isDescendantOf(['a', 'b', 'a.b', 'a.b.c'].map(el))
+
+  it('should return true if isDescendantOf', () => {
+    expect(predicate(el('a'))).toBe(true)
+    expect(predicate(el('b.c'))).toBe(true)
+    expect(predicate(el('a.b.c.d.e'))).toBe(true)
+  })
+  it('should return false if not descendantOf', () => {
+    expect(predicate(el('c'))).toBe(false)
+    expect(predicate(el('ac'))).toBe(false)
+    expect(predicate(el('d.a.c'))).toBe(false)
+  })
+})
+
+describe('notDescendantOf', () => {
+  const predicate = notDescendantOf(['a', 'b', 'a.b', 'a.b.c'].map(el))
+
+  it('should return true if notDescendantOf', () => {
+    expect(predicate(el('c'))).toBe(true)
+    expect(predicate(el('ac'))).toBe(true)
+    expect(predicate(el('d.a.c'))).toBe(true)
+  })
+  it('should return false if descendantOf', () => {
+    expect(predicate(el('a'))).toBe(false)
+    expect(predicate(el('b.c'))).toBe(false)
+    expect(predicate(el('a.b.c.d.e'))).toBe(false)
+  })
+})
+
+describe('compareFqnHierarchically', () => {
+  it('should compare hierarchically', () => {
+    expect(['a', 'b', 'a.b', 'a.b.c', 'a.c.c'].sort(compareFqnHierarchically)).toEqual([
+      'a',
+      'b',
+      'a.b',
+      'a.b.c',
+      'a.c.c'
+    ])
+  })
+
+  it('should preserve initial order', () => {
+    expect(
+      ['aaa', 'aa', 'a', 'aaa.c', 'aa.b', 'a.c', 'a.b'].sort(compareFqnHierarchically)
+    ).toEqual(['aaa', 'aa', 'a', 'aaa.c', 'aa.b', 'a.c', 'a.b'])
+  })
+})

package/src/utils/fqn.ts

@@ -0,0 +1,112 @@
+import type { Element, Fqn } from '../types'
+import { isString } from './guards'
+
+export function nameFromFqn(fqn: Fqn) {
+  const lastDot = fqn.lastIndexOf('.')
+  if (lastDot > 0) {
+    return fqn.slice(lastDot + 1)
+  } else {
+    return fqn
+  }
+}
+
+export function isAncestor<E extends { id: Fqn }>(
+  ...args: [ancestor: string, another: string] | [ancestor: E, another: E]
+) {
+  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<E extends { id: Fqn }>(one: E | Fqn, another: E | Fqn) {
+  const first = isString(one) ? one : one.id
+  const second = isString(another) ? another : another.id
+  return first === second || second.startsWith(first + '.') || first.startsWith(second + '.')
+}
+
+export function isDescendantOf<E extends { id: Fqn }>(ancestors: E[]): (e: E) => boolean {
+  const predicates = ancestors.flatMap(a => [(e: E) => e.id === a.id, (e: E) => isAncestor(a, e)])
+  return (e: E) => predicates.some(p => p(e))
+}
+
+export function notDescendantOf(ancestors: Element[]): (e: Element) => boolean {
+  const isDescendant = isDescendantOf(ancestors)
+  return (e: Element) => !isDescendant(e)
+}
+
+export function commonAncestor(first: Fqn, second: Fqn) {
+  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: Fqn | null = null
+
+  while (a.length > 1 && b.length > 1 && !!a[0] && a[0] === b[0]) {
+    ancestor = (ancestor ? `${ancestor}.${a[0]}` : a[0]) as Fqn
+    a.shift()
+    b.shift()
+  }
+  return ancestor
+}
+
+export function parentFqn(fqn: Fqn): Fqn | null {
+  const lastDot = fqn.lastIndexOf('.')
+  if (lastDot > 0) {
+    return fqn.substring(0, lastDot) as Fqn
+  }
+  return null
+}
+
+/**
+ * Get all ancestor elements (i.e. parent, parent’s parent, etc.)
+ * (from closest to root)
+ */
+export function ancestorsFqn(fqn: Fqn): Fqn[] {
+  const path = fqn.split('.')
+  path.pop()
+  if (path.length === 0) {
+    return []
+  }
+  return path.reduce((acc, _, idx) => {
+    const ancestor = path.slice(0, idx + 1).join('.')
+    acc.unshift(ancestor as Fqn)
+    return acc
+  }, [] as Fqn[])
+}
+
+/**
+ * Compares two fully qualified names (fqns) hierarchically based on their depth.
+ * From parent nodes to leaves
+ *
+ * @param {string} a - The first fqn to compare.
+ * @param {string} b - The second fqn to compare.
+ * @returns {number} - 0 if the fqns have the same depth.
+ *                    - Positive number if a is deeper than b.
+ *                    - Negative number if b is deeper than a.
+ */
+export function compareFqnHierarchically<T extends string = string>(a: T, b: T): number {
+  const depthA = a.split('.').length
+  const depthB = b.split('.').length
+  switch (true) {
+    case depthA > depthB: {
+      return 1
+    }
+    case depthA < depthB: {
+      return -1
+    }
+    default: {
+      return 0
+    }
+  }
+}
+
+export function compareByFqnHierarchically<T extends { id: string }>(a: T, b: T) {
+  return compareFqnHierarchically(a.id, b.id)
+}

package/src/utils/guards.ts

@@ -0,0 +1,10 @@
+import type { NonEmptyArray } from '../types'
+export { hasAtLeast } from 'remeda'
+
+export function isString(value: unknown): value is string {
+  return value != null && typeof value === 'string'
+}
+
+export function isNonEmptyArray<A>(arr: ArrayLike<A> | undefined): arr is NonEmptyArray<A> {
+  return !!arr && Array.isArray(arr) && arr.length > 0
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './fqn'
+export * from './guards'
+export * from './promises'
+export * from './relations'

package/src/utils/promises.ts

@@ -0,0 +1,9 @@
+const DELAY = 'LIKEC4_DELAY'
+
+export function delay(ms: number = 100) {
+  return new Promise(resolve => {
+    setTimeout(() => {
+      resolve(DELAY)
+    }, ms)
+  })
+}

package/src/utils/relations.spec.ts

@@ -0,0 +1,268 @@
+import { describe, expect, it } from 'vitest'
+import type { Fqn, Relation, RelationID } from '../types'
+import { compareRelations, Relations } from './relations'
+
+const { isAnyBetween, isAnyInOut, isBetween, isIncoming, isInside, isOutgoing } = Relations
+
+const relations = [
+  {
+    id: 'customer:cloud.frontend.dashboard' as RelationID,
+    source: 'customer' as Fqn,
+    target: 'cloud.frontend.dashboard' as Fqn,
+    title: ''
+  },
+  {
+    id: 'support:cloud.frontend.adminPanel' as RelationID,
+    source: 'support' as Fqn,
+    target: 'cloud.frontend.adminPanel' as Fqn,
+    title: ''
+  },
+  {
+    id: 'cloud.backend.storage:amazon.s3' as RelationID,
+    source: 'cloud.backend.storage' as Fqn,
+    target: 'amazon.s3' as Fqn,
+    title: ''
+  },
+  {
+    id: 'amazon.api:cloud.backend.graphql' as RelationID,
+    source: 'amazon.api' as Fqn,
+    target: 'cloud.backend.graphql' as Fqn,
+    title: ''
+  },
+  {
+    id: 'cloud.backend.graphql:cloud.backend.storage' as RelationID,
+    source: 'cloud.backend.graphql' as Fqn,
+    target: 'cloud.backend.storage' as Fqn,
+    title: ''
+  },
+  {
+    id: 'cloud.frontend.dashboard:cloud.backend.graphql' as RelationID,
+    source: 'cloud.frontend.dashboard' as Fqn,
+    target: 'cloud.backend.graphql' as Fqn,
+    title: ''
+  },
+  {
+    id: 'cloud.frontend.adminPanel:cloud.backend.graphql' as RelationID,
+    source: 'cloud.frontend.adminPanel' as Fqn,
+    target: 'cloud.backend.graphql' as Fqn,
+    title: ''
+  }
+] satisfies Relation[]
+
+describe('relation predicates', () => {
+  const expectRelations = (predicate: (relation: Relation) => boolean) =>
+    expect(relations.filter(predicate).map(r => r.id))
+
+  const customer = 'customer' as Fqn
+  const cloud = 'cloud' as Fqn
+  const frontend = 'cloud.frontend' as Fqn
+  const backend = 'cloud.backend' as Fqn
+
+  it('isBetween: cloud.frontend -> cloud.backend', () => {
+    expectRelations(isBetween(frontend, backend)).toEqual([
+      'cloud.frontend.dashboard:cloud.backend.graphql',
+      'cloud.frontend.adminPanel:cloud.backend.graphql'
+    ])
+  })
+
+  it('isBetween: cloud.frontend.dashboard -> cloud.backend', () => {
+    expectRelations(isBetween('cloud.frontend.dashboard' as Fqn, backend)).toEqual([
+      'cloud.frontend.dashboard:cloud.backend.graphql'
+    ])
+  })
+
+  it('isBetween: cloud.backend -> cloud.frontend', () => {
+    expectRelations(isBetween(backend, frontend)).toEqual([])
+  })
+
+  it('isBetween: cloud.backend -> cloud.backend', () => {
+    expectRelations(isBetween(backend, backend)).toEqual([
+      'cloud.backend.graphql:cloud.backend.storage'
+    ])
+  })
+
+  it('isBetween: customer -> cloud', () => {
+    expectRelations(isBetween(customer, cloud)).toEqual(['customer:cloud.frontend.dashboard'])
+  })
+
+  it('isIncoming: customer', () => {
+    expectRelations(isIncoming(customer)).toEqual([])
+  })
+
+  it('isIncoming: cloud', () => {
+    expectRelations(isIncoming(cloud)).toEqual([
+      'customer:cloud.frontend.dashboard',
+      'support:cloud.frontend.adminPanel',
+      'amazon.api:cloud.backend.graphql'
+    ])
+  })
+
+  it('isIncoming: cloud.frontend', () => {
+    expectRelations(isIncoming(frontend)).toEqual([
+      'customer:cloud.frontend.dashboard',
+      'support:cloud.frontend.adminPanel'
+    ])
+  })
+
+  it('isIncoming: cloud.frontend.dashboard', () => {
+    expectRelations(isIncoming('cloud.frontend.dashboard' as Fqn)).toEqual([
+      'customer:cloud.frontend.dashboard'
+    ])
+  })
+
+  it('isOutgoing: cloud', () => {
+    expectRelations(isOutgoing(cloud)).toEqual(['cloud.backend.storage:amazon.s3'])
+  })
+
+  it('isOutgoing: cloud.frontend', () => {
+    expectRelations(isOutgoing(frontend)).toEqual([
+      'cloud.frontend.dashboard:cloud.backend.graphql',
+      'cloud.frontend.adminPanel:cloud.backend.graphql'
+    ])
+  })
+
+  it('isOutgoing: cloud.backend.storage', () => {
+    expectRelations(isOutgoing('cloud.backend.storage' as Fqn)).toEqual([
+      'cloud.backend.storage:amazon.s3'
+    ])
+  })
+
+  it('isInside: cloud', () => {
+    expectRelations(isInside(cloud)).toEqual([
+      'cloud.backend.graphql:cloud.backend.storage',
+      'cloud.frontend.dashboard:cloud.backend.graphql',
+      'cloud.frontend.adminPanel:cloud.backend.graphql'
+    ])
+  })
+
+  it('isInside: cloud.frontend', () => {
+    expectRelations(isInside(frontend)).toEqual([])
+  })
+
+  it('isInside: cloud.backend', () => {
+    expectRelations(isInside(backend)).toEqual(['cloud.backend.graphql:cloud.backend.storage'])
+  })
+
+  it('isAnyInOut: customer', () => {
+    expectRelations(isAnyInOut(customer)).toEqual(['customer:cloud.frontend.dashboard'])
+  })
+
+  it('isAnyInOut: cloud', () => {
+    expectRelations(isAnyInOut(cloud)).toEqual([
+      'customer:cloud.frontend.dashboard',
+      'support:cloud.frontend.adminPanel',
+      'cloud.backend.storage:amazon.s3',
+      'amazon.api:cloud.backend.graphql'
+    ])
+  })
+
+  it('isAnyBetween: cloud and amazon', () => {
+    expectRelations(isAnyBetween(cloud, 'amazon' as Fqn)).toEqual([
+      'cloud.backend.storage:amazon.s3',
+      'amazon.api:cloud.backend.graphql'
+    ])
+  })
+})
+
+describe('compareRelations', () => {
+  function rel(source: string, target: string) {
+    return {
+      source,
+      target
+    }
+  }
+  function sorted(...relations: Array<{ source: string; target: string }>) {
+    return relations.sort(compareRelations).map(r => r.source + ' -> ' + r.target)
+  }
+
+  it('should sort by source and target', () => {
+    expect(sorted(rel('customer', 'cloud.ui'), rel('customer', 'cloud'))).toEqual([
+      'customer -> cloud',
+      'customer -> cloud.ui'
+    ])
+
+    expect(
+      sorted(
+        rel('1', '2.1'),
+        rel('1', '2'),
+        rel('1.1.1', '2'),
+        rel('1.1.1', '2.1'),
+        rel('1.1', '2')
+      )
+    ).toEqual(['1 -> 2', '1 -> 2.1', '1.1 -> 2', '1.1.1 -> 2', '1.1.1 -> 2.1'])
+  })
+
+  it('should sort by parent', () => {
+    expect(
+      sorted(
+        // same parent
+        rel('cloud.1.1', 'cloud.2.1'),
+        rel('cloud.1.1', 'cloud.2'),
+        rel('cloud.1', 'cloud.2.1'),
+        rel('cloud.1', 'cloud.2'),
+        // no same parent
+        rel('cloud.1.1', 'aws.1'),
+        rel('cloud.1', 'aws.1'),
+        rel('cloud', 'aws')
+      )
+    ).toEqual([
+      'cloud -> aws',
+      'cloud.1 -> aws.1',
+      'cloud.1.1 -> aws.1',
+      'cloud.1 -> cloud.2',
+      'cloud.1 -> cloud.2.1',
+      'cloud.1.1 -> cloud.2',
+      'cloud.1.1 -> cloud.2.1'
+    ])
+  })
+
+  it('should sort by ancestors', () => {
+    expect(
+      sorted(
+        // same parent 2nd level
+        rel('cloud.api.1', 'cloud.api.2'),
+        rel('cloud.ui.1', 'cloud.ui.2'),
+        rel('cloud.ui.2', 'cloud.ui.1'),
+        // same ancestor cloud
+        rel('cloud.ui.1', 'cloud.api.1'),
+        rel('cloud.ui.2', 'cloud.api.2'),
+        rel('cloud.ui', 'cloud.api.1'),
+        // same parent 1st level
+        rel('cloud.ui', 'cloud.api'),
+        // no same parent
+        rel('cloud.api.1', 'aws.1'),
+        rel('cloud.api', 'aws.1'),
+        rel('cloud.api', 'aws'),
+        rel('cloud.ui.1', 'aws.1'),
+        rel('cloud.ui', 'aws'),
+        rel('cloud', 'aws')
+      )
+    ).toEqual([
+      'cloud -> aws',
+      'cloud.api -> aws',
+      'cloud.ui -> aws',
+      'cloud.api -> aws.1',
+      'cloud.api.1 -> aws.1',
+      'cloud.ui.1 -> aws.1',
+      'cloud.ui -> cloud.api',
+      'cloud.ui -> cloud.api.1',
+      'cloud.ui.1 -> cloud.api.1',
+      'cloud.ui.2 -> cloud.api.2',
+      'cloud.api.1 -> cloud.api.2',
+      'cloud.ui.1 -> cloud.ui.2',
+      'cloud.ui.2 -> cloud.ui.1'
+    ])
+  })
+
+  it('should sort relations from example', () => {
+    expect(sorted(...relations)).toEqual([
+      'customer -> cloud.frontend.dashboard',
+      'support -> cloud.frontend.adminPanel',
+      'amazon.api -> cloud.backend.graphql',
+      'cloud.backend.storage -> amazon.s3',
+      'cloud.frontend.dashboard -> cloud.backend.graphql',
+      'cloud.frontend.adminPanel -> cloud.backend.graphql',
+      'cloud.backend.graphql -> cloud.backend.storage'
+    ])
+  })
+})

package/src/utils/relations.ts

@@ -0,0 +1,104 @@
+import type { Fqn } from '../types'
+import { commonAncestor, compareFqnHierarchically, isAncestor } from './fqn'
+
+type Relation = {
+  source: string
+  target: string
+}
+
+type RelationPredicate = (rel: Relation) => boolean
+
+/**
+ * Compares two relations hierarchically.
+ * From the most general (implicit) to the most specific.
+ */
+export const compareRelations = <T extends { source: string; target: string }>(a: T, b: T) => {
+  const parentA = commonAncestor(a.source as Fqn, a.target as Fqn)
+  const parentB = commonAncestor(b.source as Fqn, b.target as Fqn)
+  if (parentA && !parentB) {
+    return 1
+  }
+  if (!parentA && parentB) {
+    return -1
+  }
+  const compareParents = parentA && parentB ? compareFqnHierarchically(parentA, parentB) : 0
+  if (compareParents === 0) {
+    const compareSource = compareFqnHierarchically(a.source, b.source)
+    if (compareSource !== 0) {
+      return compareSource
+    }
+    return compareFqnHierarchically(a.target, b.target)
+  }
+  return compareParents
+}
+
+const isInside = (parent: Fqn): RelationPredicate => {
+  const prefix = parent + '.'
+  return (rel: Relation) => {
+    return rel.source.startsWith(prefix) && rel.target.startsWith(prefix)
+  }
+}
+
+const isBetween = (source: Fqn, target: Fqn): RelationPredicate => {
+  const sourcePrefix = source + '.'
+  const targetPrefix = target + '.'
+  return (rel: Relation) => {
+    return (
+      (rel.source === source || (rel.source + '.').startsWith(sourcePrefix))
+      && (rel.target === target || (rel.target + '.').startsWith(targetPrefix))
+    )
+  }
+}
+
+const isAnyBetween = (source: Fqn, target: Fqn): RelationPredicate => {
+  const predicates = [isBetween(source, target), isBetween(target, source)]
+  return (rel) => predicates.some(p => p(rel))
+}
+
+const isIncoming = (target: Fqn): RelationPredicate => {
+  const targetPrefix = target + '.'
+  return (rel: Relation) => {
+    return (
+      !(rel.source + '.').startsWith(targetPrefix)
+      && (rel.target === target || (rel.target + '.').startsWith(targetPrefix))
+    )
+  }
+}
+
+const isOutgoing = (source: Fqn): RelationPredicate => {
+  const sourcePrefix = source + '.'
+  return (rel: Relation) => {
+    return (
+      (rel.source === source || (rel.source + '.').startsWith(sourcePrefix))
+      && !(rel.target + '.').startsWith(sourcePrefix)
+    )
+  }
+}
+
+const isAnyInOut = (source: Fqn): RelationPredicate => {
+  const predicates = [isIncoming(source), isOutgoing(source)]
+  return (rel: Relation) => {
+    return predicates.some(p => p(rel))
+  }
+}
+
+const hasRelation = <R extends { source: Fqn; target: Fqn }>(rel: R) => {
+  return <E extends { id: Fqn }>(element: E) => {
+    return (
+      rel.source === element.id
+      || rel.target === element.id
+      || isAncestor(element.id, rel.source)
+      || isAncestor(element.id, rel.target)
+    )
+  }
+}
+
+export const Relations = {
+  isInside,
+  isBetween,
+  isAnyBetween,
+  isIncoming,
+  isOutgoing,
+  isAnyInOut,
+  hasRelation
+} as const

package/dist/types/computed-view.d.ts

@@ -1,52 +0,0 @@
-import type { IconUrl, NonEmptyArray } from './_common';
-import type { ElementKind, ElementShape, ElementStyle, Fqn, Tag } from './element';
-import type { Opaque } from './opaque';
-import type { RelationID, RelationshipArrowType, RelationshipLineType } from './relation';
-import type { ThemeColor } from './theme';
-import type { BasicElementView, ViewID, ViewRuleAutoLayout } from './view';
-export type NodeId = Fqn;
-export type EdgeId = Opaque<string, 'EdgeId'>;
-export interface ComputedNode {
-    id: NodeId;
-    kind: ElementKind;
-    parent: NodeId | null;
-    title: string;
-    description: string | null;
-    technology: string | null;
-    tags: NonEmptyArray<Tag> | null;
-    links: NonEmptyArray<string> | null;
-    children: NodeId[];
-    inEdges: EdgeId[];
-    outEdges: EdgeId[];
-    shape: ElementShape;
-    /**
-     * @deprecated Use `style` instead
-     */
-    color: ThemeColor;
-    /**
-     * @deprecated Use `style` instead
-     */
-    icon?: IconUrl;
-    style: ElementStyle;
-    navigateTo?: ViewID;
-    level: number;
-    depth?: number;
-}
-export interface ComputedEdge {
-    id: EdgeId;
-    parent: NodeId | null;
-    source: NodeId;
-    target: NodeId;
-    label: string | null;
-    relations: RelationID[];
-    color?: ThemeColor;
-    line?: RelationshipLineType;
-    head?: RelationshipArrowType;
-    tail?: RelationshipArrowType;
-}
-export interface ComputedView extends Omit<BasicElementView, 'rules'> {
-    readonly extends?: ViewID;
-    readonly autoLayout: ViewRuleAutoLayout['autoLayout'];
-    readonly nodes: ComputedNode[];
-    readonly edges: ComputedEdge[];
-}

package/dist/types/computed-view.js

@@ -1 +0,0 @@
-export {};