@astrale-os/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/src/ui/project.ts

@@ -0,0 +1,219 @@
+import { access, lstat, readFile, realpath } from 'node:fs/promises'
+import path from 'node:path'
+
+import { UiError, type PackageManager } from './model'
+
+export type UiProject = {
+  root: string
+  packageJsonPath: string
+  packageJson: Record<string, unknown>
+  manager: PackageManager
+  lockPath?: string
+  cssPath: string
+  componentsPath: string
+  uiLockPath: string
+  isAstraleDomain: boolean
+}
+
+const MANAGERS: readonly [string, PackageManager][] = [
+  ['pnpm-lock.yaml', 'pnpm'],
+  ['bun.lock', 'bun'],
+  ['bun.lockb', 'bun'],
+  ['yarn.lock', 'yarn'],
+  ['package-lock.json', 'npm'],
+]
+
+async function exists(target: string): Promise<boolean> {
+  return access(target).then(
+    () => true,
+    () => false,
+  )
+}
+
+async function readManifest(target: string): Promise<Record<string, unknown>> {
+  try {
+    return JSON.parse(await readFile(target, 'utf8')) as Record<string, unknown>
+  } catch (cause) {
+    throw new UiError('UI_PROJECT_UNSUPPORTED', 'package.json is not valid JSON.', undefined, {
+      cause,
+    })
+  }
+}
+
+function hasReactTailwind(manifest: Record<string, unknown>): boolean {
+  const dependencies = {
+    ...(manifest.dependencies as Record<string, string> | undefined),
+    ...(manifest.devDependencies as Record<string, string> | undefined),
+    ...(manifest.peerDependencies as Record<string, string> | undefined),
+  }
+  return Boolean(dependencies.react && dependencies['react-dom'] && dependencies.tailwindcss)
+}
+
+async function assertPhysicalProjectPath(root: string, target: string): Promise<void> {
+  const physicalRoot = await realpath(root)
+  let existing = target
+  while (!(await exists(existing))) {
+    const parent = path.dirname(existing)
+    if (parent === existing) break
+    existing = parent
+  }
+  const physicalTarget = await realpath(existing)
+  const relative = path.relative(physicalRoot, physicalTarget)
+  if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) {
+    throw new UiError('UI_PROJECT_UNSUPPORTED', 'components.json CSS path escapes the project.')
+  }
+}
+
+export async function discoverUiProject(input = process.cwd()): Promise<UiProject> {
+  let root = path.resolve(input)
+  if (!(await exists(root))) {
+    throw new UiError('UI_PROJECT_UNSUPPORTED', 'Project path does not exist: ' + root)
+  }
+  if (!(await lstat(root)).isDirectory()) root = path.dirname(root)
+
+  while (true) {
+    const manifestPath = path.join(root, 'package.json')
+    if (await exists(manifestPath)) {
+      const manifest = await readManifest(manifestPath)
+      const parent = path.dirname(root)
+      if (hasReactTailwind(manifest) || parent === root) break
+      if (await exists(path.join(parent, 'package.json'))) {
+        root = parent
+        continue
+      }
+      break
+    }
+    const parent = path.dirname(root)
+    if (parent === root) {
+      throw new UiError(
+        'UI_PROJECT_UNSUPPORTED',
+        'No package.json found from ' + path.resolve(input),
+        'Run the command inside an existing React application or pass its path.',
+      )
+    }
+    root = parent
+  }
+
+  const packageJsonPath = path.join(root, 'package.json')
+  const packageJson = await readManifest(packageJsonPath)
+
+  let manager: PackageManager = 'npm'
+  let lockPath: string | undefined
+  for (const [file, candidate] of MANAGERS) {
+    const target = path.join(root, file)
+    if (await exists(target)) {
+      manager = candidate
+      lockPath = target
+      break
+    }
+  }
+  const declared = packageJson.packageManager
+  if (!lockPath && typeof declared === 'string') {
+    const candidate = declared.split('@')[0]
+    if (
+      candidate === 'pnpm' ||
+      candidate === 'npm' ||
+      candidate === 'yarn' ||
+      candidate === 'bun'
+    ) {
+      manager = candidate
+    }
+  }
+  if (!lockPath) {
+    const expectedLock = {
+      pnpm: 'pnpm-lock.yaml',
+      npm: 'package-lock.json',
+      yarn: 'yarn.lock',
+      bun: 'bun.lock',
+    }[manager]
+    lockPath = path.join(root, expectedLock)
+  }
+
+  const rootCssCandidates = ['src/index.css', 'src/app.css', 'app/globals.css', 'src/styles.css']
+  const frontendCssCandidates = [
+    'frontend/src/index.css',
+    'frontend/src/app.css',
+    'frontend/src/styles.css',
+  ]
+  const componentsPath = path.join(root, 'components.json')
+  const configuredCss = await readFile(componentsPath, 'utf8')
+    .then((value) => {
+      const components = JSON.parse(value) as { tailwind?: { css?: unknown } }
+      const css = components.tailwind?.css
+      if (typeof css !== 'string' || css.length === 0) return undefined
+      const target = path.resolve(root, css)
+      const relative = path.relative(root, target)
+      if (relative === '..' || relative.startsWith('..' + path.sep) || path.isAbsolute(relative)) {
+        throw new UiError('UI_PROJECT_UNSUPPORTED', 'components.json CSS path escapes the project.')
+      }
+      return { relative: relative.split(path.sep).join('/'), target }
+    })
+    .catch((error: unknown) => {
+      if (error instanceof UiError) throw error
+      return undefined
+    })
+  const configuredCssRelative = configuredCss?.relative
+  const cssCandidates =
+    configuredCssRelative !== undefined
+      ? [configuredCssRelative]
+      : (await exists(path.join(root, 'frontend/package.json')))
+        ? [...frontendCssCandidates, ...rootCssCandidates]
+        : [...rootCssCandidates, ...frontendCssCandidates]
+  const resolvedCss = await Promise.all(
+    cssCandidates.map(async (file) => ((await exists(path.join(root, file))) ? file : undefined)),
+  )
+  const cssRelative = configuredCssRelative ?? resolvedCss.find(Boolean) ?? 'src/astrale-ui.css'
+  await assertPhysicalProjectPath(root, path.join(root, cssRelative))
+
+  return {
+    root,
+    packageJsonPath,
+    packageJson,
+    manager,
+    lockPath,
+    cssPath: path.join(root, cssRelative),
+    componentsPath,
+    uiLockPath: path.join(root, 'astrale-ui.lock.json'),
+    isAstraleDomain:
+      (await exists(path.join(root, 'astrale.config.ts'))) &&
+      (await exists(path.join(root, 'ui/index.ts'))) &&
+      (await exists(path.join(root, 'frontend/package.json'))),
+  }
+}
+
+export function assertSupportedUiProject(project: UiProject): void {
+  const manifest = project.packageJson
+  const dependencies = {
+    ...(manifest.dependencies as Record<string, string> | undefined),
+    ...(manifest.devDependencies as Record<string, string> | undefined),
+    ...(manifest.peerDependencies as Record<string, string> | undefined),
+  }
+  if (!dependencies.react || !dependencies['react-dom']) {
+    throw new UiError(
+      'UI_PROJECT_UNSUPPORTED',
+      'Astrale UI requires an existing React application.',
+      'Install React first or choose a non-UI project scaffold.',
+    )
+  }
+  const tailwind = dependencies.tailwindcss
+  if (!tailwind || !/(?:^|[^0-9])4(?:\.|$)/u.test(tailwind)) {
+    throw new UiError(
+      'UI_PROJECT_UNSUPPORTED',
+      'Astrale UI V1 requires Tailwind CSS 4.',
+      'Upgrade Tailwind to v4 before initializing Astrale UI.',
+    )
+  }
+}
+
+export function projectRelative(project: UiProject, target: string): string {
+  const relative = path.relative(project.root, target)
+  if (
+    relative === '' ||
+    relative === '..' ||
+    relative.startsWith('..' + path.sep) ||
+    path.isAbsolute(relative)
+  ) {
+    throw new UiError('UI_LOCK_INVALID', 'Path escapes the project root: ' + target)
+  }
+  return relative.split(path.sep).join('/')
+}

package/src/ui/release.ts

@@ -0,0 +1,321 @@
+import { UiError, type UiCompatibility, type UiRegistry, type UiRelease } from './model'
+
+const NPM_PACKAGE = 'https://registry.npmjs.org/@astrale-os/ui'
+const GITHUB_API = 'https://api.github.com/repos/astrale-os/ui'
+const RAW = 'https://raw.githubusercontent.com/astrale-os/ui'
+const MAX_DOCUMENT_BYTES = 1_048_576
+const MAX_REGISTRY_DOCUMENTS = 100
+
+type Fetch = typeof fetch
+type RegistrySource = {
+  name?: string
+  homepage?: string
+  include?: string[]
+  items?: unknown[]
+}
+
+async function json<T>(fetcher: Fetch, url: string, label: string): Promise<T> {
+  let response: Response
+  try {
+    response = await fetcher(url, { headers: { accept: 'application/json' } })
+  } catch (cause) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'Unable to reach ' + label + '.', undefined, {
+      cause,
+    })
+  }
+  if (!response.ok) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' returned HTTP ' + response.status + '.')
+  }
+  const declaredLength = Number(response.headers.get('content-length'))
+  if (Number.isFinite(declaredLength) && declaredLength > MAX_DOCUMENT_BYTES) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' exceeds the supported response size.')
+  }
+  if (!response.body) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' returned an empty response.')
+  }
+  const reader = response.body.getReader()
+  const chunks: Uint8Array[] = []
+  let bytes = 0
+  while (true) {
+    const result = await reader.read()
+    if (result.done) break
+    bytes += result.value.byteLength
+    if (bytes > MAX_DOCUMENT_BYTES) {
+      await reader.cancel()
+      throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' exceeds the supported response size.')
+    }
+    chunks.push(result.value)
+  }
+  const body = new Uint8Array(bytes)
+  let offset = 0
+  for (const chunk of chunks) {
+    body.set(chunk, offset)
+    offset += chunk.byteLength
+  }
+  try {
+    return JSON.parse(new TextDecoder().decode(body)) as T
+  } catch (cause) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', label + ' returned malformed JSON.', undefined, {
+      cause,
+    })
+  }
+}
+
+export async function resolveUiRelease(
+  requested?: string,
+  fetcher: Fetch = fetch,
+): Promise<UiRelease> {
+  const versionDocument = requested
+    ? { version: requested.replace(/^v/u, '') }
+    : await json<{ version: string }>(fetcher, NPM_PACKAGE + '/beta', 'npm UI release')
+  const version = versionDocument.version
+  if (!/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/u.test(version)) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'Invalid UI release version: ' + version)
+  }
+  if (!requested && !/-beta\.\d+$/u.test(version)) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'Invalid UI beta release version: ' + version)
+  }
+  const ref = 'v' + version
+  const reference = await json<{
+    object: { type: 'commit' | 'tag'; sha: string; url: string }
+  }>(fetcher, GITHUB_API + '/git/ref/tags/' + encodeURIComponent(ref), 'UI ref ' + ref)
+  const commit =
+    reference.object.type === 'commit'
+      ? reference.object.sha
+      : (
+          await json<{ object: { sha: string } }>(
+            fetcher,
+            reference.object.url,
+            'annotated UI tag ' + ref,
+          )
+        ).object.sha
+  if (!/^[0-9a-f]{40}$/u.test(commit)) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI ref ' + ref + ' did not resolve to a commit.')
+  }
+  return readUiReleaseSnapshot({ version, ref, commit }, fetcher)
+}
+
+export async function readUiReleaseSnapshot(
+  identity: Pick<UiRelease, 'version' | 'ref' | 'commit'>,
+  fetcher: Fetch = fetch,
+): Promise<UiRelease> {
+  const [compatibility, registry] = await Promise.all([
+    json<UiCompatibility>(
+      fetcher,
+      RAW + '/' + identity.commit + '/tooling/compatibility.json',
+      'UI compatibility metadata',
+    ),
+    readRegistry(identity.commit, fetcher),
+  ])
+  if (
+    compatibility.version !== 1 ||
+    compatibility.base !== 'base' ||
+    compatibility.style !== 'nova' ||
+    !/^\d+\.\d+\.\d+$/u.test(compatibility.shadcn)
+  ) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI compatibility metadata is invalid.')
+  }
+  return { ...identity, compatibility, registry }
+}
+
+async function readRegistry(commit: string, fetcher: Fetch): Promise<UiRegistry> {
+  const candidate = RAW + '/' + commit + '/registry.json'
+  const root = await json<RegistrySource>(fetcher, candidate, 'UI registry')
+  const items = await resolveRegistryItems(root, candidate, commit, fetcher, new Set([candidate]))
+  const publicItems = items.filter(
+    (item) =>
+      !(item && typeof item === 'object' && (item as { type?: unknown }).type === 'registry:base'),
+  )
+  if (!publicItems.every(isInstallableItem)) {
+    throw new UiError(
+      'UI_REGISTRY_UNAVAILABLE',
+      'UI registry contains an invalid installable item.',
+    )
+  }
+  const installable = publicItems
+  if (installable.length === 0) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry has no installable items.')
+  }
+  if (
+    new Set(installable.map((item) => item.name)).size !== installable.length ||
+    new Set(installable.map((item) => item.meta.canonicalAddress)).size !== installable.length
+  ) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry contains duplicate item identities.')
+  }
+  return { name: root.name ?? 'astrale-ui', homepage: root.homepage, items: installable }
+}
+
+async function resolveRegistryItems(
+  source: RegistrySource,
+  sourceUrl: string,
+  commit: string,
+  fetcher: Fetch,
+  visited: Set<string>,
+): Promise<unknown[]> {
+  const releaseRoot = RAW + '/' + commit + '/'
+  const sourceRelative = sourceUrl.slice(releaseRoot.length)
+  const sourceDirectory = sourceRelative.slice(0, Math.max(0, sourceRelative.lastIndexOf('/')))
+  const direct = Array.isArray(source.items)
+    ? source.items.map((item) => qualifyRegistryItemPaths(item, sourceDirectory))
+    : []
+  const includes = source.include ?? []
+  if (!Array.isArray(includes)) {
+    throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry include must be an array.')
+  }
+  if (visited.size + includes.length > MAX_REGISTRY_DOCUMENTS) {
+    throw new UiError(
+      'UI_REGISTRY_UNAVAILABLE',
+      'UI registry contains too many included documents.',
+    )
+  }
+  const nested = await Promise.all(
+    includes.map(async (include) => {
+      if (
+        typeof include !== 'string' ||
+        !isSafeRelative(include) ||
+        !/^[A-Za-z0-9._/-]+$/u.test(include) ||
+        !include.endsWith('registry.json') ||
+        include === 'registry.json'
+      ) {
+        throw new UiError('UI_REGISTRY_UNAVAILABLE', 'UI registry contains an unsafe include.')
+      }
+      const sourceDirectoryUrl = sourceUrl.slice(0, sourceUrl.lastIndexOf('/') + 1)
+      const url = new URL(include, sourceUrl).toString()
+      if (
+        url !== sourceDirectoryUrl + include ||
+        !url.startsWith(releaseRoot) ||
+        !url.startsWith(sourceDirectoryUrl) ||
+        visited.has(url)
+      ) {
+        throw new UiError(
+          'UI_REGISTRY_UNAVAILABLE',
+          'UI registry include escaped or repeated the release snapshot.',
+        )
+      }
+      visited.add(url)
+      const child = await json<RegistrySource>(fetcher, url, 'UI registry include')
+      return resolveRegistryItems(child, url, commit, fetcher, visited)
+    }),
+  )
+  return direct.concat(nested.flat())
+}
+
+function qualifyRegistryItemPaths(item: unknown, sourceDirectory: string): unknown {
+  if (!item || typeof item !== 'object') return item
+  const candidate = item as { files?: unknown }
+  if (!Array.isArray(candidate.files)) return item
+  return {
+    ...candidate,
+    files: candidate.files.map((file) => {
+      if (!file || typeof file !== 'object') return file
+      const candidateFile = file as { path?: unknown }
+      if (typeof candidateFile.path !== 'string') return file
+      if (
+        !isSafeRelative(candidateFile.path) ||
+        (sourceDirectory !== '' &&
+          (candidateFile.path === sourceDirectory ||
+            candidateFile.path.startsWith(sourceDirectory + '/')))
+      ) {
+        throw new UiError(
+          'UI_REGISTRY_UNAVAILABLE',
+          'UI registry contains an invalid installable item path.',
+        )
+      }
+      if (sourceDirectory === '') return file
+      const qualified = sourceDirectory + '/' + candidateFile.path
+      if (!isSafeRelative(qualified)) {
+        throw new UiError(
+          'UI_REGISTRY_UNAVAILABLE',
+          'UI registry contains an invalid installable item path.',
+        )
+      }
+      return { ...candidateFile, path: qualified }
+    }),
+  }
+}
+
+function isInstallableItem(item: unknown): item is UiRegistry['items'][number] {
+  if (!item || typeof item !== 'object') return false
+  const candidate = item as Partial<UiRegistry['items'][number]>
+  return (
+    typeof candidate.name === 'string' &&
+    /^(?:pattern|block)-[a-z0-9-]+$/u.test(candidate.name) &&
+    candidate.type === 'registry:block' &&
+    (candidate.dependencies === undefined ||
+      (Array.isArray(candidate.dependencies) &&
+        candidate.dependencies.every(
+          (dependency) =>
+            typeof dependency === 'string' &&
+            /^(?:@[a-z0-9-]+\/)?[a-z0-9-]+@[~^<>=0-9A-Za-z.* -]+$/u.test(dependency),
+        ))) &&
+    Array.isArray(candidate.files) &&
+    candidate.files.length > 0 &&
+    candidate.files.every(
+      (file) =>
+        file &&
+        typeof file.path === 'string' &&
+        isSafeRelative(file.path) &&
+        typeof file.type === 'string' &&
+        typeof file.target === 'string' &&
+        file.target.startsWith('components/astrale/') &&
+        isSafeRelative(file.target),
+    ) &&
+    typeof candidate.meta?.canonicalAddress === 'string' &&
+    /^(?:pattern|block)\/[a-z0-9-]+\/[a-z0-9-/]+$/u.test(candidate.meta.canonicalAddress)
+  )
+}
+
+export async function readUiRegistryItem(
+  release: UiRelease,
+  expected: UiRegistry['items'][number],
+  fetcher: Fetch = fetch,
+): Promise<UiRegistry['items'][number]> {
+  const item = await json<unknown>(
+    fetcher,
+    registryItemUrl(release, expected.name),
+    'UI registry item ' + expected.name,
+  )
+  if (
+    !isInstallableItem(item) ||
+    item.name !== expected.name ||
+    item.meta.canonicalAddress !== expected.meta.canonicalAddress ||
+    item.files.length !== expected.files.length ||
+    item.files.some((file, index) => {
+      const declared = expected.files[index]
+      return (
+        typeof file.content !== 'string' ||
+        file.content.length === 0 ||
+        !declared ||
+        file.path !== declared.path ||
+        file.type !== declared.type ||
+        file.target !== declared.target
+      )
+    })
+  ) {
+    throw new UiError(
+      'UI_REGISTRY_UNAVAILABLE',
+      'UI registry item ' + expected.name + ' does not match the admitted release index.',
+    )
+  }
+  return item
+}
+
+function isSafeRelative(value: string): boolean {
+  const segments = value.split('/')
+  return (
+    value.length > 0 &&
+    !value.startsWith('/') &&
+    !/^[A-Za-z]:[\\/]/u.test(value) &&
+    !value.includes('\\') &&
+    !/[?#%]/u.test(value) &&
+    ![...value].some((character) => {
+      const code = character.codePointAt(0) ?? 0
+      return code <= 31 || code === 127
+    }) &&
+    segments.every((segment) => segment.length > 0 && segment !== '.' && segment !== '..')
+  )
+}
+
+export function registryItemUrl(release: UiRelease, itemName: string): string {
+  return RAW + '/' + release.commit + '/registry/public/r/' + encodeURIComponent(itemName) + '.json'
+}

package/src/ui/runner.ts

@@ -0,0 +1,18 @@
+import type { PackageManager } from './model'
+
+import { run, type RunResult } from '../lib/proc'
+
+export type UiRunner = (file: string, args: string[], cwd: string) => Promise<RunResult>
+
+export const defaultUiRunner: UiRunner = (file, args, cwd) => run(file, args, { cwd })
+
+export function shadcnInvocation(
+  manager: PackageManager,
+  version: string,
+  args: string[],
+): { file: string; args: string[] } {
+  if (manager === 'pnpm') return { file: 'pnpm', args: ['dlx', 'shadcn@' + version, ...args] }
+  if (manager === 'bun') return { file: 'bunx', args: ['shadcn@' + version, ...args] }
+  if (manager === 'yarn') return { file: 'yarn', args: ['dlx', 'shadcn@' + version, ...args] }
+  return { file: 'npx', args: ['--yes', 'shadcn@' + version, ...args] }
+}

package/studio/client/dist/assets/elk-api-DjmKsHXc.js

@@ -0,0 +1 @@
+import{r as e,t}from"./rolldown-runtime-Dd_uD5pT.js";var n=t(((t,n)=>{(function(e){if(typeof t==`object`&&n!==void 0)n.exports=e();else if(typeof define==`function`&&define.amd)define([],e);else{var r=typeof window<`u`?window:typeof global<`u`?global:typeof self<`u`?self:this;r.ELK=e()}})(function(){return(function(){function t(n,r,i){function a(s,c){if(!r[s]){if(!n[s]){var l=typeof e==`function`&&e;if(!c&&l)return l(s,!0);if(o)return o(s,!0);var u=Error(`Cannot find module '`+s+`'`);throw u.code=`MODULE_NOT_FOUND`,u}var d=r[s]={exports:{}};n[s][0].call(d.exports,function(e){var t=n[s][1][e];return a(t||e)},d,d.exports,t,n,r,i)}return r[s].exports}for(var o=typeof e==`function`&&e,s=0;s<i.length;s++)a(i[s]);return a}return t})()({1:[function(e,t,n){Object.defineProperty(n,"__esModule",{value:!0}),n.default=void 0;function r(e){"@babel/helpers - typeof";return r=typeof Symbol==`function`&&typeof Symbol.iterator==`symbol`?function(e){return typeof e}:function(e){return e&&typeof Symbol==`function`&&e.constructor===Symbol&&e!==Symbol.prototype?`symbol`:typeof e},r(e)}function i(e,t){if(!(e instanceof t))throw TypeError(`Cannot call a class as a function`)}function a(e,t){for(var n=0;n<t.length;n++){var r=t[n];r.enumerable=r.enumerable||!1,r.configurable=!0,`value`in r&&(r.writable=!0),Object.defineProperty(e,s(r.key),r)}}function o(e,t,n){return t&&a(e.prototype,t),n&&a(e,n),Object.defineProperty(e,"prototype",{writable:!1}),e}function s(e){var t=c(e,`string`);return r(t)==`symbol`?t:t+``}function c(e,t){if(r(e)!=`object`||!e)return e;var n=e[Symbol.toPrimitive];if(n!==void 0){var i=n.call(e,t||`default`);if(r(i)!=`object`)return i;throw TypeError(`@@toPrimitive must return a primitive value.`)}return(t===`string`?String:Number)(e)}n.default=function(){function e(){var t=this,n=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},r=n.defaultLayoutOptions,a=r===void 0?{}:r,o=n.algorithms,s=o===void 0?[`layered`,`stress`,`mrtree`,`radial`,`force`,`disco`,`sporeOverlap`,`sporeCompaction`,`rectpacking`]:o,c=n.workerFactory,u=n.workerUrl;if(i(this,e),this.defaultLayoutOptions=a,this.initialized=!1,u===void 0&&c===void 0)throw Error(`Cannot construct an ELK without both 'workerUrl' and 'workerFactory'.`);var d=c;u!==void 0&&c===void 0&&(d=function(e){return new Worker(e)});var f=d(u);if(typeof f.postMessage!=`function`)throw TypeError(`Created worker does not provide the required 'postMessage' function.`);this.worker=new l(f),this.worker.postMessage({cmd:`register`,algorithms:s}).then(function(e){return t.initialized=!0}).catch(console.err)}return o(e,[{key:`layout`,value:function(e){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},n=t.layoutOptions,r=n===void 0?this.defaultLayoutOptions:n,i=t.logging,a=i!==void 0&&i,o=t.measureExecutionTime,s=o!==void 0&&o;return e?this.worker.postMessage({cmd:`layout`,graph:e,layoutOptions:r,options:{logging:a,measureExecutionTime:s}}):Promise.reject(Error(`Missing mandatory parameter 'graph'.`))}},{key:`knownLayoutAlgorithms`,value:function(){return this.worker.postMessage({cmd:`algorithms`})}},{key:`knownLayoutOptions`,value:function(){return this.worker.postMessage({cmd:`options`})}},{key:`knownLayoutCategories`,value:function(){return this.worker.postMessage({cmd:`categories`})}},{key:`terminateWorker`,value:function(){this.worker&&this.worker.terminate()}}])}();var l=function(){function e(t){var n=this;if(i(this,e),t===void 0)throw Error(`Missing mandatory parameter 'worker'.`);this.resolvers={},this.worker=t,this.worker.onmessage=function(e){setTimeout(function(){n.receive(n,e)},0)}}return o(e,[{key:`postMessage`,value:function(e){var t=this.id||0;this.id=t+1,e.id=t;var n=this;return new Promise(function(r,i){n.resolvers[t]=function(e,t){e?(n.convertGwtStyleError(e),i(e)):r(t)},n.worker.postMessage(e)})}},{key:`receive`,value:function(e,t){var n=t.data,r=e.resolvers[n.id];r&&(delete e.resolvers[n.id],n.error?r(n.error):r(null,n.data))}},{key:`terminate`,value:function(){this.worker&&this.worker.terminate()}},{key:`convertGwtStyleError`,value:function(e){if(e){var t=e.__java$exception;t&&(t.cause&&t.cause.backingJsObject&&(e.cause=t.cause.backingJsObject,this.convertGwtStyleError(e.cause)),delete e.__java$exception)}}}])}()},{}],2:[function(e,t,n){var r=e("./elk-api.js").default;Object.defineProperty(t.exports,"__esModule",{value:!0}),t.exports=r,r.default=r},{"./elk-api.js":1}]},{},[2])(2)})}));export default n();