@reqquest/ui 1.17.0 → 1.18.0

package/cli/config.js

@@ -0,0 +1,105 @@
+/**
+ * The SvelteKit and Vite configuration for a downstream ReqQuest UI.
+ *
+ * `reqquest-ui sync` writes .reqquest/svelte.config.js and .reqquest/vite.config.js as two-line stubs
+ * that import these functions by absolute path. Keeping the real configuration here, inside the
+ * package, means every plugin below resolves from @reqquest/ui's own dependencies - the downstream
+ * project never declares vite, the adapter, tailwind or the preprocessors, so their versions are
+ * whatever this release of @reqquest/ui was built and tested with.
+ *
+ * Mirrors ui/svelte.config.js and ui/vite.config.ts; change them together.
+ */
+import { join } from 'node:path'
+import adapter from '@sveltejs/adapter-static'
+import { sveltekit } from '@sveltejs/kit/vite'
+import { vitePreprocess } from '@sveltejs/vite-plugin-svelte'
+import carbonSvelteTailwind from '@txstate-mws/carbon-svelte/tailwind'
+import autoprefixer from 'autoprefixer'
+import { optimizeImports } from 'carbon-preprocess-svelte'
+import tailwindcss from 'tailwindcss'
+import { packageDir } from './util.js'
+
+/**
+ * @param {{ projectRoot: string, appRoot: string, basePath?: string }} opts
+ *   projectRoot - the downstream project (holds src/local, src/routes, package.json)
+ *   appRoot - the generated .reqquest/ directory SvelteKit runs in
+ * @returns {import('@sveltejs/kit').Config}
+ */
+export function svelteConfig ({ projectRoot, appRoot, basePath = '' }) {
+  return {
+    preprocess: [vitePreprocess(), optimizeImports()],
+    kit: {
+      adapter: adapter({
+        pages: join(projectRoot, 'build'),
+        assets: join(projectRoot, 'build'),
+        fallback: 'index.html',
+        precompress: true
+      }),
+      output: {
+        preloadStrategy: 'preload-mjs'
+      },
+      paths: {
+        base: basePath
+      },
+      files: {
+        // $lib keeps meaning the project's own src/lib, as it would in any SvelteKit app
+        lib: join(projectRoot, 'src/lib')
+      },
+      alias: {
+        $internal: 'src/internal',
+        // the downstream registry is not copied: it is aliased in place so the editor, HMR and
+        // svelte-check all work on the files the developer actually edits
+        $local: join(projectRoot, 'src/local')
+      },
+      typescript: {
+        // SvelteKit's generated tsconfig only includes the app root, which src/local and src/lib sit outside of
+        config (tsconfig) {
+          for (const dir of ['src/local', 'src/lib']) {
+            const abs = join(projectRoot, dir)
+            tsconfig.include.push(`${abs}/**/*.ts`, `${abs}/**/*.js`, `${abs}/**/*.svelte`)
+          }
+        }
+      }
+    }
+  }
+}
+
+/**
+ * @param {{ projectRoot: string, appRoot: string }} opts
+ * @returns {import('vite').UserConfig}
+ */
+export function viteConfig ({ projectRoot, appRoot }) {
+  const globs = '**/*.{html,js,svelte,ts}'
+  return {
+    plugins: [sveltekit()],
+    build: {
+      sourcemap: true
+    },
+    optimizeDeps: {
+      exclude: ['carbon-icons-svelte']
+    },
+    server: {
+      fs: {
+        allow: [projectRoot, packageDir('@txstate-mws/carbon-svelte', appRoot)]
+      }
+    },
+    // inline so that no postcss.config.js / tailwind.config.js is needed in either the project or
+    // .reqquest/, and so the plugins resolve from this package rather than the project
+    css: {
+      postcss: {
+        plugins: [
+          tailwindcss({
+            content: [
+              join(appRoot, 'src', globs),
+              join(projectRoot, 'src/local', globs),
+              join(projectRoot, 'src/lib', globs),
+              join(packageDir('@txstate-mws/carbon-svelte', appRoot), globs)
+            ],
+            plugins: [carbonSvelteTailwind]
+          }),
+          autoprefixer()
+        ]
+      }
+    }
+  }
+}

package/cli/sync.js

@@ -0,0 +1,296 @@
+/**
+ * Assembles .reqquest/ - a complete SvelteKit project - from the app shell shipped in this package
+ * plus the downstream project's own files.
+ *
+ *   node_modules/@reqquest/ui/app/src/routes   base routes (read-only)
+ *            +  <project>/src/routes            developer overrides and additions
+ *            =  .reqquest/src/routes            what SvelteKit builds
+ *
+ * Overlay rules, applied in this order:
+ *   1. package.json "reqquest": { "disableRoutes": ["roles/users"] } removes those base route folders
+ *   2. a `.reqquest-replace` file in a developer folder removes the base folder of the same path, so
+ *      the developer's version stands alone (use when an override page needs different load data)
+ *   3. every developer file is copied over the base; same path = override, new path = addition
+ *
+ * src/local is never copied - svelteConfig() aliases $local to it in place. src/internal is base-only:
+ * every route depends on it, so letting it be overridden would freeze it as public API.
+ *
+ * Overriding a base file forks it. reqquest-overrides.lock.json (committed, in the project root)
+ * records the hash of each base file at the time it was overridden, so an upgrade that changes the
+ * file underneath an override is reported instead of silently diverging.
+ *
+ * The generated tree is reconciled rather than wiped: unchanged files are not rewritten, so a
+ * running dev server only sees what actually changed, and .reqquest/.svelte-kit and the Vite cache
+ * survive.
+ */
+import { createHash } from 'node:crypto'
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs'
+import { dirname, join, relative, resolve, sep } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { packageDir, readJson } from './util.js'
+
+const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), '..')
+const APP = join(PACKAGE_ROOT, 'app')
+const MARKER = '.reqquest-replace'
+const LOCKFILE = 'reqquest-overrides.lock.json'
+const GENERATED_NOTE = 'generated by `reqquest-ui sync` - do not edit; it is rewritten on every sync'
+
+export class SyncError extends Error {}
+
+/**
+ * @param {string} projectRoot
+ * @param {{ strict?: boolean, accept?: boolean, quiet?: boolean }} [opts]
+ *   strict - fail instead of warn on drift or an out-of-date lockfile (CI / docker builds)
+ *   accept - re-record the current base hashes in the lockfile, acknowledging any drift
+ * @returns {{ appRoot: string, warnings: string[] }}
+ */
+export function sync (projectRoot, { strict = false, accept = false, quiet = false } = {}) {
+  if (!existsSync(APP)) throw new SyncError(`${APP} is missing - this @reqquest/ui was not packed with its app shell.`)
+  const appRoot = join(projectRoot, '.reqquest')
+  const pkg = readJson(join(projectRoot, 'package.json'))
+  const options = pkg.reqquest ?? {}
+  const warnings = []
+
+  checkToolchain(projectRoot)
+  if (!existsSync(join(projectRoot, 'src/local/index.ts')) && !existsSync(join(projectRoot, 'src/local/index.js'))) {
+    throw new SyncError('src/local/index.ts not found. It must export `uiRegistry` - see docs/downstream-ui.md in the reqquest repo.')
+  }
+
+  /** @type {Map<string, Buffer>} path relative to appRoot -> contents */
+  const files = new Map()
+
+  // -- src: base shell, then the route overlay
+  for (const rel of walk(join(APP, 'src'))) files.set(join('src', rel), readFileSync(join(APP, 'src', rel)))
+  const overrides = overlayRoutes(projectRoot, files, options, warnings)
+
+  // -- static: base, then the project's own
+  for (const rel of walk(join(APP, 'static'))) files.set(join('static', rel), readFileSync(join(APP, 'static', rel)))
+  for (const rel of walk(join(projectRoot, 'static'))) files.set(join('static', rel), readFileSync(join(projectRoot, 'static', rel)))
+
+  // -- config stubs and env
+  const configModule = pathToFileURL(join(PACKAGE_ROOT, 'cli/config.js')).href
+  const configArgs = JSON.stringify({ projectRoot, appRoot, basePath: options.basePath ?? '' })
+  files.set('svelte.config.js', Buffer.from(`// ${GENERATED_NOTE}\nimport { svelteConfig } from '${configModule}'\nexport default svelteConfig(${configArgs})\n`))
+  files.set('vite.config.js', Buffer.from(`// ${GENERATED_NOTE}\nimport { viteConfig } from '${configModule}'\nexport default viteConfig(${configArgs})\n`))
+  files.set('tsconfig.json', Buffer.from(JSON.stringify({
+    '//': GENERATED_NOTE,
+    extends: './.svelte-kit/tsconfig.json',
+    compilerOptions: { sourceMap: true, strictNullChecks: true, skipLibCheck: true }
+  }, null, 2) + '\n'))
+  // vite-plugin-svelte crawls the root package.json's dependencies to find svelte libraries to
+  // prebundle in dev, so list what @reqquest/ui's own package.json would - they resolve upward from here
+  const ui = readJson(join(PACKAGE_ROOT, 'package.json'))
+  files.set('package.json', Buffer.from(JSON.stringify({
+    '//': GENERATED_NOTE,
+    name: `${pkg.name ?? 'app'}-reqquest`,
+    private: true,
+    type: 'module',
+    dependencies: { '@reqquest/ui': ui.version, ...ui.dependencies, ...pkg.dependencies },
+    devDependencies: ui.peerDependencies
+  }, null, 2) + '\n'))
+  files.set('.env', mergeEnv(readFileSync(join(APP, 'env.template'), 'utf8'), join(projectRoot, '.env')))
+
+  reconcile(appRoot, files, ['src', 'static'])
+  updateLock(projectRoot, overrides, { strict, accept, warnings })
+  ensureRootTsconfig(projectRoot, warnings)
+
+  if (!quiet) for (const w of warnings) console.warn(`reqquest-ui: ${w}`)
+  return { appRoot, warnings }
+}
+
+/**
+ * The toolchain packages that must be single, top-level copies (svelte, kit, vite, the svelte vite
+ * plugin) are exact-pinned peers of @reqquest/ui. npm installs them for the project, but if the
+ * project's own package.json declares a different version npm only warns ("ERESOLVE overriding peer
+ * dependency") and installs that one. This is the check that actually stops the drift, and every
+ * reqquest-ui command runs it.
+ */
+function checkToolchain (projectRoot) {
+  const { peerDependencies = {}, version } = readJson(join(PACKAGE_ROOT, 'package.json'))
+  for (const [name, wanted] of Object.entries(peerDependencies)) {
+    let installed
+    try {
+      installed = readJson(join(packageDir(name, join(projectRoot, '.reqquest')), 'package.json')).version
+    } catch {
+      throw new SyncError(`${name} is not installed. It is a peer dependency of @reqquest/ui - run npm install.`)
+    }
+    if (installed !== wanted) {
+      throw new SyncError(`@reqquest/ui ${version} requires ${name} ${wanted} but ${installed} is installed. ` +
+        `Remove ${name} from your package.json - @reqquest/ui provides it - and reinstall.`)
+    }
+  }
+}
+
+/**
+ * Applies the developer's src/routes onto the base routes already in `files`.
+ * @returns {Map<string, string>} base route path (relative to routes/) -> hash of the base content
+ *   the developer has forked, either by overriding the file or by replacing its folder
+ */
+function overlayRoutes (projectRoot, files, options, warnings) {
+  const routesKey = join('src', 'routes')
+  const baseRoutes = new Map()
+  for (const [path, content] of files) {
+    if (path.startsWith(routesKey + sep)) baseRoutes.set(relative(routesKey, path), content)
+  }
+  const deleteBase = (prefix) => {
+    let found = false
+    for (const rel of baseRoutes.keys()) {
+      if (rel === prefix || rel.startsWith(prefix + sep)) {
+        files.delete(join(routesKey, rel))
+        found = true
+      }
+    }
+    return found
+  }
+  const forked = new Map()
+
+  for (const route of options.disableRoutes ?? []) {
+    const prefix = normalizeRoute(route)
+    if (!deleteBase(prefix)) warnings.push(`disableRoutes: "${route}" matches no ReqQuest route - check the spelling.`)
+  }
+
+  const devRoot = join(projectRoot, 'src', 'routes')
+  const devFiles = walk(devRoot)
+
+  for (const rel of devFiles) {
+    if (rel.split(sep).pop() !== MARKER) continue
+    const prefix = dirname(rel) === '.' ? '' : dirname(rel)
+    for (const [baseRel, content] of baseRoutes) {
+      if (prefix === '' || baseRel.startsWith(prefix + sep)) forked.set(baseRel, hash(content))
+    }
+    if (prefix === '') {
+      for (const baseRel of baseRoutes.keys()) files.delete(join(routesKey, baseRel))
+    } else if (!deleteBase(prefix)) {
+      warnings.push(`${join('src/routes', rel)} replaces "${prefix}", which is not a ReqQuest route - the marker does nothing.`)
+    }
+  }
+
+  const escapes = []
+  for (const rel of devFiles) {
+    if (rel.split(sep).pop() === MARKER) continue
+    const content = readFileSync(join(devRoot, rel))
+    escapes.push(...escapingImports(devRoot, rel, content))
+    if (baseRoutes.has(rel)) forked.set(rel, hash(baseRoutes.get(rel)))
+    files.set(join(routesKey, rel), content)
+  }
+  if (escapes.length) {
+    throw new SyncError('Route files are copied into .reqquest/ before building, so a relative import that leaves src/routes would break:\n' +
+      escapes.map(e => `  ${e}`).join('\n') +
+      '\nImport through an alias instead: $lib for src/lib, $local for src/local.')
+  }
+  return forked
+}
+
+const IMPORT_RE = /(?:\bfrom\s*|\bimport\s*\(\s*|\bimport\s+)(['"])(\.{1,2}\/[^'"]*)\1/g
+
+function escapingImports (devRoot, rel, content) {
+  if (!/\.(svelte|[cm]?[jt]s)$/.test(rel)) return []
+  const found = []
+  for (const [, , spec] of content.toString('utf8').matchAll(IMPORT_RE)) {
+    const target = resolve(devRoot, dirname(rel), spec)
+    if (relative(devRoot, target).startsWith('..')) found.push(`${join('src/routes', rel)}: '${spec}'`)
+  }
+  return found
+}
+
+function updateLock (projectRoot, forked, { strict, accept, warnings }) {
+  const lockPath = join(projectRoot, LOCKFILE)
+  const previous = existsSync(lockPath) ? readJson(lockPath).files ?? {} : {}
+  const problems = []
+  const next = {}
+
+  for (const [path, baseHash] of [...forked].sort(([a], [b]) => a.localeCompare(b))) {
+    if (!(path in previous)) {
+      problems.push(`new override of src/routes/${path} is not recorded`)
+      next[path] = baseHash
+    } else if (previous[path] !== baseHash && !accept) {
+      warnings.push(`ReqQuest changed src/routes/${path} since you overrode it. Compare your copy with ` +
+        `node_modules/@reqquest/ui/app/src/routes/${path}, then run \`reqquest-ui sync --accept\`.`)
+      problems.push(`src/routes/${path} drifted from its base`)
+      next[path] = previous[path] // keep the old hash so the warning repeats until reviewed
+    } else {
+      next[path] = baseHash
+    }
+  }
+  for (const path of Object.keys(previous)) {
+    if (!forked.has(path)) problems.push(`src/routes/${path} is listed but no longer an override`)
+  }
+
+  if (strict && problems.length) {
+    throw new SyncError(`${LOCKFILE} is out of date:\n${problems.map(p => `  ${p}`).join('\n')}\n` +
+      'Run `npx reqquest-ui sync` locally (add --accept once you have reviewed any drift) and commit the lockfile.')
+  }
+  if (JSON.stringify(next) === JSON.stringify(previous)) return
+  if (Object.keys(next).length) writeFileSync(lockPath, JSON.stringify({ '//': 'written by `reqquest-ui sync` - commit it', files: next }, null, 2) + '\n')
+  else rmSync(lockPath, { force: true })
+}
+
+function ensureRootTsconfig (projectRoot, warnings) {
+  const path = join(projectRoot, 'tsconfig.json')
+  const wanted = './.reqquest/tsconfig.json'
+  if (!existsSync(path)) {
+    writeFileSync(path, JSON.stringify({ extends: wanted }, null, 2) + '\n')
+  } else if (!readFileSync(path, 'utf8').includes(wanted)) {
+    warnings.push(`tsconfig.json does not extend "${wanted}", so your editor will not resolve $local, $internal or the route types. Replace it with { "extends": "${wanted}" }.`)
+  }
+}
+
+/** Template keys first, project .env overriding by key. */
+function mergeEnv (template, projectEnv) {
+  const lines = new Map()
+  const add = text => {
+    for (const line of text.split('\n')) {
+      const m = /^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=/.exec(line)
+      if (m) lines.set(m[1], line)
+    }
+  }
+  add(template)
+  if (existsSync(projectEnv)) add(readFileSync(projectEnv, 'utf8'))
+  return Buffer.from([...lines.values()].join('\n') + '\n')
+}
+
+/**
+ * Makes appRoot match `files`. Within `managedDirs`, anything not in `files` is deleted; elsewhere
+ * (.svelte-kit, node_modules/.vite) is left alone. Generated files are made read-only so an
+ * accidental edit fails instead of being silently overwritten by the next sync.
+ */
+function reconcile (appRoot, files, managedDirs) {
+  for (const dir of managedDirs) {
+    for (const rel of walk(join(appRoot, dir))) {
+      if (!files.has(join(dir, rel))) rmSync(join(appRoot, dir, rel), { force: true })
+    }
+  }
+  for (const [rel, content] of files) {
+    const path = join(appRoot, rel)
+    if (existsSync(path) && readFileSync(path).equals(content)) continue
+    mkdirSync(dirname(path), { recursive: true })
+    if (existsSync(path)) chmodSync(path, 0o644)
+    writeFileSync(path, content)
+    chmodSync(path, 0o444)
+  }
+  for (const dir of managedDirs) pruneEmptyDirs(join(appRoot, dir))
+}
+
+function pruneEmptyDirs (dir) {
+  if (!existsSync(dir)) return
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    if (entry.isDirectory()) pruneEmptyDirs(join(dir, entry.name))
+  }
+  if (readdirSync(dir).length === 0) rmSync(dir, { recursive: true })
+}
+
+/** Relative paths of every file under `root`, or [] if it does not exist. */
+function walk (root) {
+  if (!existsSync(root) || !statSync(root).isDirectory()) return []
+  return readdirSync(root, { recursive: true, withFileTypes: true })
+    .filter(e => e.isFile())
+    .map(e => relative(root, join(e.parentPath, e.name)))
+}
+
+function normalizeRoute (route) {
+  return route.replace(/^\/+|\/+$/g, '').split('/').join(sep)
+}
+
+function hash (content) {
+  return createHash('sha256').update(content).digest('hex').slice(0, 16)
+}

package/cli/util.js

@@ -0,0 +1,29 @@
+import { existsSync, readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+/**
+ * Finds an installed package's directory by walking node_modules upward from `from`, the way Node
+ * resolves a bare import. Used instead of require.resolve because several of these packages declare
+ * "exports" that do not expose package.json.
+ */
+export function packageDir (name, from) {
+  let dir = from
+  while (true) {
+    const candidate = join(dir, 'node_modules', name)
+    if (existsSync(join(candidate, 'package.json'))) return candidate
+    const parent = dirname(dir)
+    if (parent === dir) throw new Error(`Cannot find package '${name}' from ${from}. Is @reqquest/ui installed?`)
+    dir = parent
+  }
+}
+
+export function readJson (path) {
+  return JSON.parse(readFileSync(path, 'utf8'))
+}
+
+/** Absolute path of a package's executable, from its package.json "bin". */
+export function packageBin (name, from, binName = name.split('/').pop()) {
+  const dir = packageDir(name, from)
+  const { bin } = readJson(join(dir, 'package.json'))
+  return join(dir, typeof bin === 'string' ? bin : bin[binName])
+}

package/dist/components.md

@@ -5271,10 +5271,6 @@ import TagSkeleton from '@txstate-mws/carbon-svelte/dist/TagSkeleton.svelte'
 import UserImpersonation from '@txstate-mws/carbon-svelte/dist/UserImpersonation.svelte'
 ```
 
-`@reqquest/ui` has one of these too: `DelayedSkeleton` is compiled into `dist/components/` but is not
-re-exported from the barrel. The framework's own screens use it via `$lib`; downstream code should
-register a `loader` on the prompt instead of mounting it directly.
-
 ### When this file is not enough
 
 - **Props, exactly.** `carbon-svelte` ships unbundled, so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reqquest/ui",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "overrides": {
     "esrap": "2.3.2"
   },
@@ -11,8 +11,14 @@
       "default": "./dist/index.js"
     }
   },
+  "bin": {
+    "reqquest-ui": "bin/reqquest-ui.js"
+  },
   "files": [
-    "dist"
+    "dist",
+    "app",
+    "bin",
+    "cli"
   ],
   "scripts": {
     "prepare": "svelte-kit sync",
@@ -20,40 +26,48 @@
     "build": "vite build",
     "preview": "vite preview",
     "package": "svelte-kit sync && svelte-package",
-    "prepublishOnly": "npm run package",
     "check": "svelte-check --tsconfig ./tsconfig.json",
     "check:registry": "node check-registry.js",
     "docs:components": "node scripts/build-components-md.js",
     "docs:components:check": "node scripts/build-components-md.js --check",
-    "check:watch": "svelte-check --tsconfig ./tsconfig.json --watch"
+    "check:watch": "svelte-check --tsconfig ./tsconfig.json --watch",
+    "prepack": "npm run package && node scripts/pack-app.js"
   },
   "peerDependencies": {
-    "@sveltejs/kit": "^2.0.0",
-    "svelte": "^5.0.0"
+    "@sveltejs/kit": "2.70.3",
+    "@sveltejs/vite-plugin-svelte": "6.2.4",
+    "svelte": "5.57.2",
+    "vite": "7.3.7"
   },
   "dependencies": {
+    "@sveltejs/adapter-static": "3.0.10",
     "@txstate-mws/carbon-svelte": "^1.5.5",
     "@txstate-mws/fastify-shared": "^1.1.0",
     "@txstate-mws/svelte-components": "^1.6.11",
+    "@txstate-mws/svelte-forms": "2.1.10",
     "@txstate-mws/sveltekit-utils": "^1.0.2",
+    "autoprefixer": "10.6.1",
+    "carbon-components-svelte": "0.112.2",
+    "carbon-icons-svelte": "13.16.0",
+    "carbon-preprocess-svelte": "0.11.49",
     "luxon": "^3.5.0",
-    "txstate-utils": "^1.8.15"
+    "postcss": "8.5.29",
+    "svelte-check": "4.7.6",
+    "tailwindcss": "3.4.19",
+    "txstate-utils": "^1.8.15",
+    "typescript": "5.9.3"
   },
   "devDependencies": {
     "@stylistic/eslint-plugin": "^5.0.0",
-    "@sveltejs/adapter-static": "^3.0.1",
-    "@sveltejs/kit": "^2.5.2",
+    "@sveltejs/kit": "2.70.3",
     "@sveltejs/package": "^2.0.0",
-    "@sveltejs/vite-plugin-svelte": "^6.0.0",
+    "@sveltejs/vite-plugin-svelte": "6.2.4",
     "@types/luxon": "^3.4.2",
     "@types/node": "^24.3.1",
-    "carbon-preprocess-svelte": "~0.11.2",
     "eslint-config-love": "^151.0.0",
     "eslint-plugin-svelte": "^3.0.0",
-    "svelte": "^5.0.0",
-    "svelte-check": "^4.0.0",
-    "typescript": "^5.3.3",
-    "vite": "^7.0.0"
+    "svelte": "5.57.2",
+    "vite": "7.3.7"
   },
   "type": "module"
 }

package/dist/components/DelayedSkeleton.svelte.d.ts

@@ -1,21 +0,0 @@
-import type { Loader } from "../registry";
-interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
-    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
-        $$bindings?: Bindings;
-    } & Exports;
-    (internal: unknown, props: Props & {
-        $$events?: Events;
-        $$slots?: Slots;
-    }): Exports & {
-        $set?: any;
-        $on?: any;
-    };
-    z_$$bindings?: Bindings;
-}
-declare const DelayedSkeleton: $$__sveltets_2_IsomorphicComponent<{
-    loader: Loader;
-}, {
-    [evt: string]: CustomEvent<any>;
-}, {}, {}, string>;
-type DelayedSkeleton = InstanceType<typeof DelayedSkeleton>;
-export default DelayedSkeleton;