@cratis/scene.engine 0.1.0

package/for_evaluateFlowArrangement/when_evaluating_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,67 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ExternalComponent, FlowArrangement, FlowLeaf, FlowOverride, HeightSizeClass, HorizontalAlignment, SizeClass, VerticalAlignment, Visibility, WidthSizeClass } from '@cratis/scene.model';
+import { evaluateFlowArrangement } from '../index';
+
+interface FixtureOverride {
+    width: WidthSizeClass | null;
+    height: HeightSizeClass | null;
+    tag: string;
+}
+
+interface FixtureCase {
+    name: string;
+    rootTag: string;
+    overrides: FixtureOverride[];
+    sizeClass: SizeClass;
+    expectedTag: string;
+}
+
+interface FixtureCorpus {
+    flowCases: FixtureCase[];
+}
+
+const manifestPath = join(import.meta.dirname, '..', '..', '..', '..', 'layout-evaluation-fixtures.json');
+const corpus = JSON.parse(readFileSync(manifestPath, 'utf-8')) as FixtureCorpus;
+
+function leaf(tag: string): FlowLeaf {
+    const content: ExternalComponent = {
+        id: tag,
+        name: tag,
+        properties: {},
+        visibility: Visibility.Visible,
+        isEnabled: true,
+        opacity: 1,
+        size: {},
+        zIndex: 0,
+        minimumSize: {},
+        maximumSize: {},
+        margin: { left: 0, top: 0, right: 0, bottom: 0 },
+        horizontalAlignment: HorizontalAlignment.Stretch,
+        verticalAlignment: VerticalAlignment.Stretch,
+        componentName: 'core:text',
+        slots: {},
+    };
+    return { content };
+}
+
+describe('when evaluating against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.flowCases) {
+        it(`should match the expected tag for "${fixtureCase.name}"`, () => {
+            const arrangement: FlowArrangement = {
+                root: leaf(fixtureCase.rootTag),
+                overrides: fixtureCase.overrides.map((override): FlowOverride => ({
+                    width: override.width ?? undefined,
+                    height: override.height ?? undefined,
+                    root: leaf(override.tag),
+                })),
+            };
+
+            const result = evaluateFlowArrangement(arrangement, fixtureCase.sizeClass) as FlowLeaf;
+            (result.content as ExternalComponent).id.should.equal(fixtureCase.expectedTag);
+        });
+    }
+});

package/for_evaluateFreeformArrangement/when_evaluating_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,68 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ElementPlacement, ExternalComponent, FreeformArrangement, HeightSizeClass, HorizontalAlignment, SizeClass, VerticalAlignment, Visibility, WidthSizeClass } from '@cratis/scene.model';
+import { evaluateFreeformArrangement } from '../index';
+
+interface FixtureVariant {
+    width: WidthSizeClass;
+    height: HeightSizeClass;
+    tag: string;
+}
+
+interface FixtureCase {
+    name: string;
+    variants: FixtureVariant[];
+    sizeClass: SizeClass;
+    expectedTag: string | null;
+}
+
+interface FixtureCorpus {
+    freeformCases: FixtureCase[];
+}
+
+const manifestPath = join(import.meta.dirname, '..', '..', '..', '..', 'layout-evaluation-fixtures.json');
+const corpus = JSON.parse(readFileSync(manifestPath, 'utf-8')) as FixtureCorpus;
+
+function placement(tag: string): ElementPlacement {
+    const element: ExternalComponent = {
+        id: tag,
+        name: tag,
+        properties: {},
+        visibility: Visibility.Visible,
+        isEnabled: true,
+        opacity: 1,
+        size: {},
+        zIndex: 0,
+        minimumSize: {},
+        maximumSize: {},
+        margin: { left: 0, top: 0, right: 0, bottom: 0 },
+        horizontalAlignment: HorizontalAlignment.Stretch,
+        verticalAlignment: VerticalAlignment.Stretch,
+        componentName: 'core:text',
+        slots: {},
+    };
+    return { element, x: 0, y: 0, width: 0, height: 0 };
+}
+
+describe('when evaluating against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.freeformCases) {
+        it(`should match the expected tag for "${fixtureCase.name}"`, () => {
+            const arrangement: FreeformArrangement = {
+                variants: fixtureCase.variants.map(variant => ({
+                    sizeClass: { width: variant.width, height: variant.height },
+                    placements: [placement(variant.tag)],
+                })),
+            };
+
+            const result = evaluateFreeformArrangement(arrangement, fixtureCase.sizeClass);
+            if (fixtureCase.expectedTag === null) {
+                (result === undefined).should.be.true;
+            } else {
+                (result!.placements[0].element as ExternalComponent).id.should.equal(fixtureCase.expectedTag);
+            }
+        });
+    }
+});

package/for_evaluateFreeformSlotArrangement/when_evaluating_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,47 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { FreeformSlotArrangement, HeightSizeClass, SizeClass, WidthSizeClass } from '@cratis/scene.model';
+import { evaluateFreeformSlotArrangement } from '../index';
+
+interface FixtureVariant {
+    width: WidthSizeClass;
+    height: HeightSizeClass;
+    tag: string;
+}
+
+interface FixtureCase {
+    name: string;
+    variants: FixtureVariant[];
+    sizeClass: SizeClass;
+    expectedTag: string | null;
+}
+
+interface FixtureCorpus {
+    freeformCases: FixtureCase[];
+}
+
+const manifestPath = join(import.meta.dirname, '..', '..', '..', '..', 'layout-evaluation-fixtures.json');
+const corpus = JSON.parse(readFileSync(manifestPath, 'utf-8')) as FixtureCorpus;
+
+describe('when evaluating against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.freeformCases) {
+        it(`should match the expected tag for "${fixtureCase.name}"`, () => {
+            const arrangement: FreeformSlotArrangement = {
+                variants: fixtureCase.variants.map(variant => ({
+                    sizeClass: { width: variant.width, height: variant.height },
+                    placements: [{ slotName: variant.tag, x: 0, y: 0, width: 0, height: 0 }],
+                })),
+            };
+
+            const result = evaluateFreeformSlotArrangement(arrangement, fixtureCase.sizeClass);
+            if (fixtureCase.expectedTag === null) {
+                (result === undefined).should.be.true;
+            } else {
+                result!.placements[0].slotName.should.equal(fixtureCase.expectedTag);
+            }
+        });
+    }
+});

package/for_incompatibleStarterThemes/when_checking_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,34 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Theme, UiStarter } from '@cratis/scene.model';
+import { incompatibleStarterThemes } from '../index';
+
+interface FixtureCase {
+    name: string;
+    starter: UiStarter;
+    themes: Record<string, Theme>;
+    expectedIncompatible: string[];
+}
+
+interface FixtureCorpus {
+    themeCases: FixtureCase[];
+}
+
+const manifestPath = join(import.meta.dirname, '..', '..', '..', '..', 'ui-starter-fixtures.json');
+const corpus = JSON.parse(readFileSync(manifestPath, 'utf-8')) as FixtureCorpus;
+
+describe('when checking against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.themeCases) {
+        const themes: Record<string, Theme> = {};
+        for (const [themeName, theme] of Object.entries(fixtureCase.themes)) {
+            themes[themeName] = { name: themeName, compatibleWith: theme.compatibleWith };
+        }
+
+        it(`should match the expected incompatible themes for "${fixtureCase.name}"`, () => {
+            incompatibleStarterThemes(fixtureCase.starter, themes).should.deep.equal(fixtureCase.expectedIncompatible);
+        });
+    }
+});

package/for_packageCatalog/when_querying_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,26 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { availablePackagesFor, baseComponentLibraries, componentsForPackages } from '../index';
+import { CatalogFixtureCase, corpus } from '../for_packageDependencies/fixtures';
+
+function run(fixtureCase: CatalogFixtureCase): string[] {
+    switch (fixtureCase.query) {
+        case 'baseComponentLibraries':
+            return baseComponentLibraries(corpus.catalog).map((scenePackage) => scenePackage.name);
+        case 'availableFor':
+            return availablePackagesFor(corpus.catalog, fixtureCase.selected ?? []).map((scenePackage) => scenePackage.name);
+        case 'componentsFor':
+            return componentsForPackages(corpus.catalog, fixtureCase.selected ?? []);
+        default:
+            throw new Error(`The fixture corpus asks for an unknown query '${fixtureCase.query}'`);
+    }
+}
+
+describe('when querying against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.catalogCases) {
+        it(`should match the expected result for "${fixtureCase.name}"`, () => {
+            run(fixtureCase).should.deep.equal(fixtureCase.expected);
+        });
+    }
+});

package/for_packageDependencies/fixtures.ts

@@ -0,0 +1,44 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { ScenePackage } from '@cratis/scene.model';
+
+export interface ResolutionFixtureCase {
+    name: string;
+    selected: string[];
+    expectedPackages: string[];
+    expectedAdded: string[];
+    expectedMissing: { package: string; dependsOn: string }[];
+    expectedVersionConflicts: { package: string; dependsOn: string; requiredRange: string; actualVersion: string }[];
+    expectedCycles: string[][];
+}
+
+export interface VersionRangeFixtureCase {
+    version: string;
+    range: string | null;
+    expected: boolean;
+}
+
+export interface CatalogFixtureCase {
+    name: string;
+    query: string;
+    selected?: string[];
+    expected: string[];
+}
+
+interface FixtureCorpus {
+    catalog: ScenePackage[];
+    resolutionCases: ResolutionFixtureCase[];
+    versionRangeCases: VersionRangeFixtureCase[];
+    catalogCases: CatalogFixtureCase[];
+}
+
+const fixturePath = join(import.meta.dirname, '..', '..', '..', '..', 'package-dependency-fixtures.json');
+
+/**
+ * The same corpus the C# specs read, so both languages resolve against an identical catalog rather than
+ * two hand-written ones that can quietly diverge.
+ */
+export const corpus = JSON.parse(readFileSync(fixturePath, 'utf-8')) as FixtureCorpus;

package/for_packageDependencies/when_resolving_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,39 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { isPackageSelectionValid, resolvePackageDependencies } from '../index';
+import { corpus } from './fixtures';
+
+describe('when resolving against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.resolutionCases) {
+        const selection = resolvePackageDependencies(fixtureCase.selected, corpus.catalog);
+
+        it(`should order the packages as expected for "${fixtureCase.name}"`, () => {
+            selection.packages.should.deep.equal(fixtureCase.expectedPackages);
+        });
+
+        it(`should report the expected transitively added packages for "${fixtureCase.name}"`, () => {
+            selection.added.should.deep.equal(fixtureCase.expectedAdded);
+        });
+
+        it(`should report the expected missing dependencies for "${fixtureCase.name}"`, () => {
+            selection.missing.should.deep.equal(fixtureCase.expectedMissing);
+        });
+
+        it(`should report the expected version conflicts for "${fixtureCase.name}"`, () => {
+            selection.versionConflicts.should.deep.equal(fixtureCase.expectedVersionConflicts);
+        });
+
+        it(`should report the expected cycles for "${fixtureCase.name}"`, () => {
+            selection.cycles.should.deep.equal(fixtureCase.expectedCycles);
+        });
+
+        it(`should consider "${fixtureCase.name}" valid only when nothing is wrong`, () => {
+            const expectedValid =
+                fixtureCase.expectedMissing.length === 0 &&
+                fixtureCase.expectedVersionConflicts.length === 0 &&
+                fixtureCase.expectedCycles.length === 0;
+            isPackageSelectionValid(selection).should.equal(expectedValid);
+        });
+    }
+});

package/for_packageVersionRange/when_checking_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,13 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { isVersionSatisfiedBy } from '../index';
+import { corpus } from '../for_packageDependencies/fixtures';
+
+describe('when checking against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.versionRangeCases) {
+        it(`should decide ${fixtureCase.version} against '${fixtureCase.range ?? '<null>'}' the same way the corpus does`, () => {
+            isVersionSatisfiedBy(fixtureCase.version, fixtureCase.range ?? undefined).should.equal(fixtureCase.expected);
+        });
+    }
+});

package/for_renderElement/when_rendering_a_mixed_tree.ts

@@ -0,0 +1,58 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ContentControl, Control, ExternalComponent, HorizontalAlignment, ItemsControl, Panel, VerticalAlignment, Visibility } from '@cratis/scene.model';
+import { Renderer, renderElement } from '../index';
+
+function control(id: string): Control {
+    return {
+        id,
+        name: id,
+        properties: {},
+        visibility: Visibility.Visible,
+        isEnabled: true,
+        opacity: 1,
+        size: {},
+        zIndex: 0,
+        minimumSize: {},
+        maximumSize: {},
+        margin: { left: 0, top: 0, right: 0, bottom: 0 },
+        horizontalAlignment: HorizontalAlignment.Stretch,
+        verticalAlignment: VerticalAlignment.Stretch,
+        borderThickness: { left: 0, top: 0, right: 0, bottom: 0 },
+        padding: { left: 0, top: 0, right: 0, bottom: 0 },
+        tabIndex: 0,
+    };
+}
+
+class StringRenderer implements Renderer<string> {
+    renderContentControl(element: ContentControl, content: string): string {
+        return `ContentControl(${element.id})[${content}]`;
+    }
+
+    renderItemsControl(element: ItemsControl, items: string[]): string {
+        return `ItemsControl(${element.id})[${items.join(',')}]`;
+    }
+
+    renderExternalComponent(element: ExternalComponent, slots: Record<string, string[]>): string {
+        const slotsText = Object.entries(slots).map(([name, children]) => `${name}=${children.join(',')}`).join(';');
+        return `ExternalComponent(${element.componentName})[${slotsText}]`;
+    }
+
+    renderPanel(element: Panel, children: string[]): string {
+        return `Panel(${element.id})[${children.join(',')}]`;
+    }
+}
+
+describe('when rendering a mixed tree', () => {
+    const badge: ExternalComponent = { ...control('badge'), componentName: 'core:badge', slots: {} };
+    const itemTemplate: ContentControl = { ...control('row'), content: badge };
+    const items: ItemsControl = { ...control('items'), itemsSource: { path: 'rows' }, itemTemplate };
+    const root: Panel = { ...control('root'), children: [items] };
+
+    const output = renderElement(root, new StringRenderer(), binding => (binding.path === 'rows' ? [{}, {}] : []));
+
+    it('should render the panel wrapping the items control', () => output.should.equal(
+        'Panel(root)[ItemsControl(items)[ContentControl(row)[ExternalComponent(core:badge)[]],ContentControl(row)[ExternalComponent(core:badge)[]]]]',
+    ));
+});

package/for_resolveComponentName/when_resolving_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,36 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { UiProfile } from '@cratis/scene.model';
+import { ComponentResolution, PackageCatalog, resolveComponentName } from '../index';
+
+interface FixtureCase {
+    name: string;
+    profile: { packages: string[] };
+    catalog: PackageCatalog;
+    requestedName: string;
+    expected: ComponentResolution | null;
+}
+
+interface FixtureCorpus {
+    cases: FixtureCase[];
+}
+
+const manifestPath = join(import.meta.dirname, '..', '..', '..', '..', 'package-resolution-fixtures.json');
+const corpus = JSON.parse(readFileSync(manifestPath, 'utf-8')) as FixtureCorpus;
+
+describe('when resolving against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.cases) {
+        it(`should match the expected resolution for "${fixtureCase.name}"`, () => {
+            const profile: UiProfile = { name: 'test', targetPlatform: 'web', packages: fixtureCase.profile.packages };
+            const actual = resolveComponentName(fixtureCase.requestedName, profile, fixtureCase.catalog);
+            if (fixtureCase.expected === null) {
+                (actual === undefined).should.be.true;
+            } else {
+                actual!.should.deep.equal(fixtureCase.expected);
+            }
+        });
+    }
+});

package/for_resolveScreenTemplates/when_resolving_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,49 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Layout, ScreenTemplate } from '@cratis/scene.model';
+import { isScreenTemplateResolutionValid, resolveScreenTemplates } from '../index';
+
+interface FixtureCase {
+    name: string;
+    layout: { name: string; slots: string[] };
+    templates: { name: string; fitsSlot: string | null; slots: string[] }[];
+    expectedPlacements: { template: string; slot: string; container: string; depth: number }[];
+    expectedUnplaced: { template: string; slot: string; candidates: string[] }[];
+    expectedCycles: string[][];
+}
+
+const fixturePath = join(import.meta.dirname, '..', '..', '..', '..', 'screen-template-fixtures.json');
+const corpus = JSON.parse(readFileSync(fixturePath, 'utf-8')) as { cases: FixtureCase[] };
+
+describe('when resolving against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.cases) {
+        const layout: Layout = { name: fixtureCase.layout.name, slots: fixtureCase.layout.slots.map((name) => ({ name })) };
+        const templates: ScreenTemplate[] = fixtureCase.templates.map((template) => ({
+            name: template.name,
+            fitsSlot: template.fitsSlot ?? undefined,
+            slots: template.slots.map((name) => ({ name })),
+        }));
+
+        const resolution = resolveScreenTemplates(layout, templates);
+
+        it(`should place every template where the corpus expects for "${fixtureCase.name}"`, () => {
+            resolution.placements.should.deep.equal(fixtureCase.expectedPlacements);
+        });
+
+        it(`should report the expected unplaced templates for "${fixtureCase.name}"`, () => {
+            resolution.unplaced.should.deep.equal(fixtureCase.expectedUnplaced);
+        });
+
+        it(`should report the expected cycles for "${fixtureCase.name}"`, () => {
+            resolution.cycles.should.deep.equal(fixtureCase.expectedCycles);
+        });
+
+        it(`should consider "${fixtureCase.name}" valid only when nothing is wrong`, () => {
+            const expectedValid = fixtureCase.expectedUnplaced.length === 0 && fixtureCase.expectedCycles.length === 0;
+            isScreenTemplateResolutionValid(resolution).should.equal(expectedValid);
+        });
+    }
+});

package/for_themeCompatibility/when_checking_against_the_shared_fixture_corpus.ts

@@ -0,0 +1,37 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Theme, UiProfile } from '@cratis/scene.model';
+import { applicableThemePackages, incompatiblePackages } from '../index';
+
+interface FixtureCase {
+    name: string;
+    theme: { compatibleWith: string[] };
+    profile: { packages: string[] };
+    expectedIncompatible: string[];
+    expectedApplicable: string[];
+}
+
+interface FixtureCorpus {
+    cases: FixtureCase[];
+}
+
+const manifestPath = join(import.meta.dirname, '..', '..', '..', '..', 'theme-compatibility-fixtures.json');
+const corpus = JSON.parse(readFileSync(manifestPath, 'utf-8')) as FixtureCorpus;
+
+describe('when checking against the shared fixture corpus', () => {
+    for (const fixtureCase of corpus.cases) {
+        const theme: Theme = { name: 'test-theme', compatibleWith: fixtureCase.theme.compatibleWith };
+        const profile: UiProfile = { name: 'test-profile', targetPlatform: 'web', packages: fixtureCase.profile.packages };
+
+        it(`should match the expected incompatible packages for "${fixtureCase.name}"`, () => {
+            incompatiblePackages(theme, profile).should.deep.equal(fixtureCase.expectedIncompatible);
+        });
+
+        it(`should match the expected applicable packages for "${fixtureCase.name}"`, () => {
+            applicableThemePackages(theme, profile).should.deep.equal(fixtureCase.expectedApplicable);
+        });
+    }
+});

package/incompatibleStarterThemes.ts

@@ -0,0 +1,24 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { Theme, UiProfile, UiStarter } from '@cratis/scene.model';
+import { incompatiblePackages } from './themeCompatibility';
+
+/**
+ * Finds the {@link UiStarter.themes} that are not compatible with the starter's own {@link UiStarter.packages} -
+ * part of Cratis/Scene#6. A starter is versioned per package combination it targets, so a theme it ships
+ * as a choice that turns out incompatible with the starter's own packages is exactly the gap
+ * `themeCompatibility` already surfaces for a {@link UiProfile}; this reuses that rule rather than
+ * reimplementing it for starters.
+ *
+ * @param starter The {@link UiStarter} to check.
+ * @param themes Every known {@link Theme}, keyed by name.
+ * @returns The names in `starter.themes` that are either unknown to `themes` or incompatible with `starter.packages`.
+ */
+export function incompatibleStarterThemes(starter: UiStarter, themes: Record<string, Theme>): string[] {
+    const profile: UiProfile = { name: starter.name, targetPlatform: '', packages: starter.packages };
+    return starter.themes.filter(name => {
+        const theme = themes[name];
+        return !theme || incompatiblePackages(theme, profile).length > 0;
+    });
+}

package/index.ts

@@ -0,0 +1,23 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export * from './Renderer';
+export * from './BindingResolver';
+export * from './renderElement';
+export * from './elementKind';
+export * from './flowNodeKind';
+export * from './ComponentResolution';
+export * from './resolveComponentName';
+export * from './computeSizeClass';
+export * from './evaluateFlowArrangement';
+export * from './evaluateFreeformArrangement';
+export * from './evaluateFreeformSlotArrangement';
+export * from './aggregateContributions';
+export * from './themeCompatibility';
+export * from './PackageSelection';
+export * from './packageVersionRange';
+export * from './resolvePackageDependencies';
+export * from './packageCatalog';
+export * from './resolveScreenTemplates';
+export * from './buildStarterProfile';
+export * from './incompatibleStarterThemes';

package/package.json

@@ -0,0 +1,45 @@
+{
+    "name": "@cratis/scene.engine",
+    "version": "0.1.0",
+    "description": "The Scene runtime: walks a Scene element tree and drives whichever renderer is plugged in. Does not know React, or any other rendering platform, exists.",
+    "author": "Cratis",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Cratis/Scene.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist",
+        "**/*.ts"
+    ],
+    "main": "dist/cjs/index.js",
+    "module": "dist/esm/index.js",
+    "types": "dist/esm/index.d.ts",
+    "exports": {
+        "./package.json": "./package.json",
+        ".": {
+            "types": "./dist/esm/index.d.ts",
+            "require": "./dist/cjs/index.js",
+            "import": "./dist/esm/index.js"
+        }
+    },
+    "scripts": {
+        "prepare": "yarn g:build",
+        "clean": "yarn g:clean",
+        "build": "yarn g:build",
+        "lint": "yarn g:lint",
+        "lint:ci": "yarn g:lint:ci",
+        "test": "yarn g:test",
+        "ci": "yarn g:ci",
+        "up": "yarn g:up"
+    },
+    "dependencies": {
+        "@cratis/scene.model": "0.1.0"
+    },
+    "devDependencies": {
+        "@cratis/scene.model": "0.1.0"
+    }
+}