@cratis/scene.model 4.6.0 → 4.8.0

package/dist/cjs/index.js

@@ -90,6 +90,7 @@ var Behavior = require('./interactions/Behavior.js');
 var Screen = require('./screens/Screen.js');
 var ScreenTemplate = require('./screens/ScreenTemplate.js');
 var DialogTemplate = require('./screens/DialogTemplate.js');
+var TemplateMetadata = require('./screens/TemplateMetadata.js');
 var UiStarter = require('./starters/UiStarter.js');
 var QueryResultShape = require('./queries/QueryResultShape.js');
 var QueryOriginKind = require('./queries/QueryOriginKind.js');
@@ -244,6 +245,8 @@ exports.BehaviorPropertyNames = Behavior.BehaviorPropertyNames;
 exports.ScreenPropertyNames = Screen.ScreenPropertyNames;
 exports.ScreenTemplatePropertyNames = ScreenTemplate.ScreenTemplatePropertyNames;
 exports.DialogTemplatePropertyNames = DialogTemplate.DialogTemplatePropertyNames;
+exports.TemplateMetadataPropertyNames = TemplateMetadata.TemplateMetadataPropertyNames;
+exports.TemplateScope = TemplateMetadata.TemplateScope;
 exports.UiStarterPropertyNames = UiStarter.UiStarterPropertyNames;
 exports.QueryResultShape = QueryResultShape.QueryResultShape;
 exports.QueryOriginKind = QueryOriginKind.QueryOriginKind;

package/dist/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/cjs/layouts/Layout.js

@@ -6,7 +6,8 @@ const LayoutPropertyNames = [
     'name',
     'slots',
     'arrangement',
-    'behaviors'
+    'behaviors',
+    'metadata'
 ];
 
 exports.LayoutPropertyNames = LayoutPropertyNames;

package/dist/cjs/layouts/Layout.js.map

@@ -1 +1 @@
-{"version":3,"file":"Layout.js","sources":["../../../layouts/Layout.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { Arrangement } from './Arrangement';\nimport { Slot } from './Slot';\nimport { Behavior } from '../interactions';\n\n/**\n * A named template of slots that a {@link Screen} fills with content. Mirrors Screenplay's `layout`\n * construct: a bare layout with plain slots is a special case of a layout whose slots all use the\n * default arrangement.\n */\nexport interface Layout {\n    name: string;\n    slots: Slot[];\n\n    /**\n     * How the layout's own `slots` position relative to each other - a {@link FlowArrangement} (leaves\n     * are {@link FlowSlotLeaf}) or {@link FreeformSlotArrangement}, or `undefined` for the slots'\n     * declaration order with no further positioning information. Distinct from each {@link Slot}'s own\n     * `arrangement`, which positions that one slot's filled content instead of positioning the slots\n     * themselves.\n     */\n    arrangement?: Arrangement;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n}\n\nexport const LayoutPropertyNames: (keyof Layout)[] = ['name', 'slots', 'arrangement', 'behaviors'];\n"],"names":["LayoutPropertyNames"],"mappings":";;AAAA;AACA;MA8BaA,mBAAAA,GAAwC;AAAC,IAAA,MAAA;AAAQ,IAAA,OAAA;AAAS,IAAA,aAAA;AAAe,IAAA;;;"}
+{"version":3,"file":"Layout.js","sources":["../../../layouts/Layout.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { Arrangement } from './Arrangement';\nimport { Slot } from './Slot';\nimport { Behavior } from '../interactions';\nimport { TemplateMetadata } from '../screens/TemplateMetadata';\n\n/**\n * A named template of slots that a {@link Screen} fills with content. Mirrors Screenplay's `layout`\n * construct: a bare layout with plain slots is a special case of a layout whose slots all use the\n * default arrangement.\n */\nexport interface Layout {\n    name: string;\n    slots: Slot[];\n\n    /**\n     * How the layout's own `slots` position relative to each other - a {@link FlowArrangement} (leaves\n     * are {@link FlowSlotLeaf}) or {@link FreeformSlotArrangement}, or `undefined` for the slots'\n     * declaration order with no further positioning information. Distinct from each {@link Slot}'s own\n     * `arrangement`, which positions that one slot's filled content instead of positioning the slots\n     * themselves.\n     */\n    arrangement?: Arrangement;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n\n    /** Optional browse metadata; ApplicationShell retains this existing Layout role. */\n    metadata?: TemplateMetadata;\n}\n\nexport const LayoutPropertyNames: (keyof Layout)[] = ['name', 'slots', 'arrangement', 'behaviors', 'metadata'];\n"],"names":["LayoutPropertyNames"],"mappings":";;AAAA;AACA;MAkCaA,mBAAAA,GAAwC;AAAC,IAAA,MAAA;AAAQ,IAAA,OAAA;AAAS,IAAA,aAAA;AAAe,IAAA,WAAA;AAAa,IAAA;;;"}

package/dist/cjs/screens/DialogTemplate.js

@@ -9,7 +9,8 @@ const DialogTemplatePropertyNames = [
     'content',
     'displayName',
     'description',
-    'behaviors'
+    'behaviors',
+    'metadata'
 ];
 
 exports.DialogTemplatePropertyNames = DialogTemplatePropertyNames;

package/dist/cjs/screens/DialogTemplate.js.map

@@ -1 +1 @@
-{"version":3,"file":"DialogTemplate.js","sources":["../../../screens/DialogTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\n\n/**\n * A reusable dialog structure — the same idea as a {@link ScreenTemplate}, for content that opens over an\n * application rather than sitting inside it.\n *\n * A dialog has no `fitsSlot` because it occupies no slot: it is an overlay, summoned by something rather\n * than placed by a containing layout. Everything else is the same, which is deliberate — a confirmation\n * dialog and a detail screen are both \"slots with an arrangement, filled with content\", and there is no\n * reason for an author to learn that twice.\n */\nexport interface DialogTemplate {\n    /**\n     * The template's name.\n     */\n    name: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other. Absent for declaration order with\n     * no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — a dialog's own chrome, such as its header\n     * and button bar.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n}\n\nexport const DialogTemplatePropertyNames: (keyof DialogTemplate)[] = [\n    'name',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n];\n"],"names":["DialogTemplatePropertyNames"],"mappings":";;AAAA;AACA;MAsDaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA;;;"}
+{"version":3,"file":"DialogTemplate.js","sources":["../../../screens/DialogTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\nimport { TemplateMetadata } from './TemplateMetadata';\n\n/**\n * A reusable dialog structure — the same idea as a {@link ScreenTemplate}, for content that opens over an\n * application rather than sitting inside it.\n *\n * A dialog has no `fitsSlot` because it occupies no slot: it is an overlay, summoned by something rather\n * than placed by a containing layout. Everything else is the same, which is deliberate — a confirmation\n * dialog and a detail screen are both \"slots with an arrangement, filled with content\", and there is no\n * reason for an author to learn that twice.\n */\nexport interface DialogTemplate {\n    /**\n     * The template's name.\n     */\n    name: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other. Absent for declaration order with\n     * no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — a dialog's own chrome, such as its header\n     * and button bar.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n\n    /** Optional semantic type, browse category and scope restrictions. */\n    metadata?: TemplateMetadata;\n}\n\nexport const DialogTemplatePropertyNames: (keyof DialogTemplate)[] = [\n    'name',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n    'metadata',\n];\n"],"names":["DialogTemplatePropertyNames"],"mappings":";;AAAA;AACA;MA0DaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA,WAAA;AACA,IAAA;;;"}

package/dist/cjs/screens/ScreenTemplate.js

@@ -10,7 +10,8 @@ const ScreenTemplatePropertyNames = [
     'content',
     'displayName',
     'description',
-    'behaviors'
+    'behaviors',
+    'metadata'
 ];
 
 exports.ScreenTemplatePropertyNames = ScreenTemplatePropertyNames;

package/dist/cjs/screens/ScreenTemplate.js.map

@@ -1 +1 @@
-{"version":3,"file":"ScreenTemplate.js","sources":["../../../screens/ScreenTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\n\n/**\n * A reusable screen structure that fills a named slot on whatever contains it, and offers slots of its\n * own for what it contains in turn.\n *\n * A {@link Layout} and a screen template are deliberately different things. A layout is the application's\n * base navigational look — the shell with its top bar, navigation and content region — and an application\n * has one. A screen template is what goes *inside* that shell, and an application has many: one per\n * module, feature or slice that needs a shape of its own.\n *\n * `fitsSlot` is what makes them compose. A module's screen template fits the application layout's content\n * slot; a feature's screen template fits a slot the module's template declares; a slice's fits one the\n * feature's declares. The same rule at every level, so nesting is arbitrarily deep without a second\n * mechanism — and a template always states where it belongs rather than being told by whatever happens to\n * host it.\n */\nexport interface ScreenTemplate {\n    /**\n     * The template's name, which a {@link Screen} refers to.\n     */\n    name: string;\n\n    /**\n     * The name of the slot on the containing {@link Layout} or screen template this one fills, or\n     * undefined for a template that is placed explicitly rather than by declaration.\n     */\n    fitsSlot?: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other — the same shape a {@link Layout}\n     * uses, evaluated by the same engine. Absent for declaration order with no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — the chrome a template brings with it, as\n     * opposed to what a {@link Screen} based on it fills in.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n}\n\nexport const ScreenTemplatePropertyNames: (keyof ScreenTemplate)[] = [\n    'name',\n    'fitsSlot',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n];\n"],"names":["ScreenTemplatePropertyNames"],"mappings":";;AAAA;AACA;MAkEaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,UAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA;;;"}
+{"version":3,"file":"ScreenTemplate.js","sources":["../../../screens/ScreenTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\nimport { TemplateMetadata } from './TemplateMetadata';\n\n/**\n * A reusable screen structure that fills a named slot on whatever contains it, and offers slots of its\n * own for what it contains in turn.\n *\n * A {@link Layout} and a screen template are deliberately different things. A layout is the application's\n * base navigational look — the shell with its top bar, navigation and content region — and an application\n * has one. A screen template is what goes *inside* that shell, and an application has many: one per\n * module, feature or slice that needs a shape of its own.\n *\n * `fitsSlot` is what makes them compose. A module's screen template fits the application layout's content\n * slot; a feature's screen template fits a slot the module's template declares; a slice's fits one the\n * feature's declares. The same rule at every level, so nesting is arbitrarily deep without a second\n * mechanism — and a template always states where it belongs rather than being told by whatever happens to\n * host it.\n */\nexport interface ScreenTemplate {\n    /**\n     * The template's name, which a {@link Screen} refers to.\n     */\n    name: string;\n\n    /**\n     * The name of the slot on the containing {@link Layout} or screen template this one fills, or\n     * undefined for a template that is placed explicitly rather than by declaration.\n     */\n    fitsSlot?: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other — the same shape a {@link Layout}\n     * uses, evaluated by the same engine. Absent for declaration order with no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — the chrome a template brings with it, as\n     * opposed to what a {@link Screen} based on it fills in.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n\n    /** Optional semantic type, browse category and scope restrictions. */\n    metadata?: TemplateMetadata;\n}\n\nexport const ScreenTemplatePropertyNames: (keyof ScreenTemplate)[] = [\n    'name',\n    'fitsSlot',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n    'metadata',\n];\n"],"names":["ScreenTemplatePropertyNames"],"mappings":";;AAAA;AACA;MAsEaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,UAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA,WAAA;AACA,IAAA;;;"}

package/dist/cjs/screens/TemplateMetadata.js

@@ -0,0 +1,21 @@
+'use strict';
+
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The application hierarchy at which a reusable template is selected. */ var TemplateScope = /*#__PURE__*/ function(TemplateScope) {
+    TemplateScope["Application"] = "Application";
+    TemplateScope["Module"] = "Module";
+    TemplateScope["Feature"] = "Feature";
+    TemplateScope["Subfeature"] = "Subfeature";
+    TemplateScope["Slice"] = "Slice";
+    return TemplateScope;
+}({});
+const TemplateMetadataPropertyNames = [
+    'type',
+    'category',
+    'scopes'
+];
+
+exports.TemplateMetadataPropertyNames = TemplateMetadataPropertyNames;
+exports.TemplateScope = TemplateScope;
+//# sourceMappingURL=TemplateMetadata.js.map

package/dist/cjs/screens/TemplateMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateMetadata.js","sources":["../../../screens/TemplateMetadata.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/** The application hierarchy at which a reusable template is selected. */\nexport enum TemplateScope {\n    Application = 'Application',\n    Module = 'Module',\n    Feature = 'Feature',\n    Subfeature = 'Subfeature',\n    Slice = 'Slice',\n}\n\n/**\n * Optional semantic and browsing metadata. Type and category are open strings so packages can\n * introduce their own vocabulary without a Scene release. Category never determines applicability.\n */\nexport interface TemplateMetadata {\n    /** Semantic role; built-in roles are ApplicationShell, Workspace, List, Detail, Form and Dialog. */\n    type?: string;\n    /** A package-defined browse category, preserved even when the host does not recognize it. */\n    category?: string;\n    /** Explicit scope restriction. Absent uses the structural role; an empty list allows no scope. */\n    scopes?: TemplateScope[];\n}\n\nexport const TemplateMetadataPropertyNames: (keyof TemplateMetadata)[] = ['type', 'category', 'scopes'];\n"],"names":["TemplateScope","TemplateMetadataPropertyNames"],"mappings":";;AAAA;AACA;AAEA,2EACO,IAAKA,aAAAA,iBAAAA,SAAAA,aAAAA,EAAAA;;;;;;AAAAA,IAAAA,OAAAA,aAAAA;AAMX,CAAA,CAAA,EAAA;MAeYC,6BAAAA,GAA4D;AAAC,IAAA,MAAA;AAAQ,IAAA,UAAA;AAAY,IAAA;;;;"}

package/dist/esm/index.js

@@ -88,6 +88,7 @@ export { BehaviorPropertyNames } from './interactions/Behavior.js';
 export { ScreenPropertyNames } from './screens/Screen.js';
 export { ScreenTemplatePropertyNames } from './screens/ScreenTemplate.js';
 export { DialogTemplatePropertyNames } from './screens/DialogTemplate.js';
+export { TemplateMetadataPropertyNames, TemplateScope } from './screens/TemplateMetadata.js';
 export { UiStarterPropertyNames } from './starters/UiStarter.js';
 export { QueryResultShape } from './queries/QueryResultShape.js';
 export { QueryOriginKind } from './queries/QueryOriginKind.js';

package/dist/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/esm/layouts/Layout.d.ts

@@ -1,11 +1,13 @@
 import { Arrangement } from './Arrangement';
 import { Slot } from './Slot';
 import { Behavior } from '../interactions';
+import { TemplateMetadata } from '../screens/TemplateMetadata';
 export interface Layout {
     name: string;
     slots: Slot[];
     arrangement?: Arrangement;
     behaviors?: Behavior[];
+    metadata?: TemplateMetadata;
 }
 export declare const LayoutPropertyNames: (keyof Layout)[];
 //# sourceMappingURL=Layout.d.ts.map

package/dist/esm/layouts/Layout.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Layout.d.ts","sourceRoot":"","sources":["../../../layouts/Layout.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAO3C,MAAM,WAAW,MAAM;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,IAAI,EAAE,CAAC;IASd,WAAW,CAAC,EAAE,WAAW,CAAC;IAK1B,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CAC1B;AAED,eAAO,MAAM,mBAAmB,EAAE,CAAC,MAAM,MAAM,CAAC,EAAkD,CAAC"}
+{"version":3,"file":"Layout.d.ts","sourceRoot":"","sources":["../../../layouts/Layout.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAC9B,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAO/D,MAAM,WAAW,MAAM;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,IAAI,EAAE,CAAC;IASd,WAAW,CAAC,EAAE,WAAW,CAAC;IAK1B,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAGvB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAED,eAAO,MAAM,mBAAmB,EAAE,CAAC,MAAM,MAAM,CAAC,EAA8D,CAAC"}

package/dist/esm/layouts/Layout.js

@@ -4,7 +4,8 @@ const LayoutPropertyNames = [
     'name',
     'slots',
     'arrangement',
-    'behaviors'
+    'behaviors',
+    'metadata'
 ];
 
 export { LayoutPropertyNames };

package/dist/esm/layouts/Layout.js.map

@@ -1 +1 @@
-{"version":3,"file":"Layout.js","sources":["../../../layouts/Layout.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { Arrangement } from './Arrangement';\nimport { Slot } from './Slot';\nimport { Behavior } from '../interactions';\n\n/**\n * A named template of slots that a {@link Screen} fills with content. Mirrors Screenplay's `layout`\n * construct: a bare layout with plain slots is a special case of a layout whose slots all use the\n * default arrangement.\n */\nexport interface Layout {\n    name: string;\n    slots: Slot[];\n\n    /**\n     * How the layout's own `slots` position relative to each other - a {@link FlowArrangement} (leaves\n     * are {@link FlowSlotLeaf}) or {@link FreeformSlotArrangement}, or `undefined` for the slots'\n     * declaration order with no further positioning information. Distinct from each {@link Slot}'s own\n     * `arrangement`, which positions that one slot's filled content instead of positioning the slots\n     * themselves.\n     */\n    arrangement?: Arrangement;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n}\n\nexport const LayoutPropertyNames: (keyof Layout)[] = ['name', 'slots', 'arrangement', 'behaviors'];\n"],"names":["LayoutPropertyNames"],"mappings":"AAAA;AACA;MA8BaA,mBAAAA,GAAwC;AAAC,IAAA,MAAA;AAAQ,IAAA,OAAA;AAAS,IAAA,aAAA;AAAe,IAAA;;;"}
+{"version":3,"file":"Layout.js","sources":["../../../layouts/Layout.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { Arrangement } from './Arrangement';\nimport { Slot } from './Slot';\nimport { Behavior } from '../interactions';\nimport { TemplateMetadata } from '../screens/TemplateMetadata';\n\n/**\n * A named template of slots that a {@link Screen} fills with content. Mirrors Screenplay's `layout`\n * construct: a bare layout with plain slots is a special case of a layout whose slots all use the\n * default arrangement.\n */\nexport interface Layout {\n    name: string;\n    slots: Slot[];\n\n    /**\n     * How the layout's own `slots` position relative to each other - a {@link FlowArrangement} (leaves\n     * are {@link FlowSlotLeaf}) or {@link FreeformSlotArrangement}, or `undefined` for the slots'\n     * declaration order with no further positioning information. Distinct from each {@link Slot}'s own\n     * `arrangement`, which positions that one slot's filled content instead of positioning the slots\n     * themselves.\n     */\n    arrangement?: Arrangement;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n\n    /** Optional browse metadata; ApplicationShell retains this existing Layout role. */\n    metadata?: TemplateMetadata;\n}\n\nexport const LayoutPropertyNames: (keyof Layout)[] = ['name', 'slots', 'arrangement', 'behaviors', 'metadata'];\n"],"names":["LayoutPropertyNames"],"mappings":"AAAA;AACA;MAkCaA,mBAAAA,GAAwC;AAAC,IAAA,MAAA;AAAQ,IAAA,OAAA;AAAS,IAAA,aAAA;AAAe,IAAA,WAAA;AAAa,IAAA;;;"}

package/dist/esm/screens/DialogTemplate.d.ts

@@ -1,6 +1,7 @@
 import { SceneElement } from '../elements';
 import { Arrangement, Slot } from '../layouts';
 import { Behavior } from '../interactions';
+import { TemplateMetadata } from './TemplateMetadata';
 export interface DialogTemplate {
     name: string;
     slots: Slot[];
@@ -9,6 +10,7 @@ export interface DialogTemplate {
     displayName?: string;
     description?: string;
     behaviors?: Behavior[];
+    metadata?: TemplateMetadata;
 }
 export declare const DialogTemplatePropertyNames: (keyof DialogTemplate)[];
 //# sourceMappingURL=DialogTemplate.d.ts.map

package/dist/esm/screens/DialogTemplate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DialogTemplate.d.ts","sourceRoot":"","sources":["../../../screens/DialogTemplate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAW3C,MAAM,WAAW,cAAc;IAI3B,IAAI,EAAE,MAAM,CAAC;IAKb,KAAK,EAAE,IAAI,EAAE,CAAC;IAMd,WAAW,CAAC,EAAE,WAAW,CAAC;IAM1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAKzC,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CAC1B;AAED,eAAO,MAAM,2BAA2B,EAAE,CAAC,MAAM,cAAc,CAAC,EAQ/D,CAAC"}
+{"version":3,"file":"DialogTemplate.d.ts","sourceRoot":"","sources":["../../../screens/DialogTemplate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAWtD,MAAM,WAAW,cAAc;IAI3B,IAAI,EAAE,MAAM,CAAC;IAKb,KAAK,EAAE,IAAI,EAAE,CAAC;IAMd,WAAW,CAAC,EAAE,WAAW,CAAC;IAM1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAKzC,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAGvB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAED,eAAO,MAAM,2BAA2B,EAAE,CAAC,MAAM,cAAc,CAAC,EAS/D,CAAC"}

package/dist/esm/screens/DialogTemplate.js

@@ -7,7 +7,8 @@ const DialogTemplatePropertyNames = [
     'content',
     'displayName',
     'description',
-    'behaviors'
+    'behaviors',
+    'metadata'
 ];
 
 export { DialogTemplatePropertyNames };

package/dist/esm/screens/DialogTemplate.js.map

@@ -1 +1 @@
-{"version":3,"file":"DialogTemplate.js","sources":["../../../screens/DialogTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\n\n/**\n * A reusable dialog structure — the same idea as a {@link ScreenTemplate}, for content that opens over an\n * application rather than sitting inside it.\n *\n * A dialog has no `fitsSlot` because it occupies no slot: it is an overlay, summoned by something rather\n * than placed by a containing layout. Everything else is the same, which is deliberate — a confirmation\n * dialog and a detail screen are both \"slots with an arrangement, filled with content\", and there is no\n * reason for an author to learn that twice.\n */\nexport interface DialogTemplate {\n    /**\n     * The template's name.\n     */\n    name: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other. Absent for declaration order with\n     * no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — a dialog's own chrome, such as its header\n     * and button bar.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n}\n\nexport const DialogTemplatePropertyNames: (keyof DialogTemplate)[] = [\n    'name',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n];\n"],"names":["DialogTemplatePropertyNames"],"mappings":"AAAA;AACA;MAsDaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA;;;"}
+{"version":3,"file":"DialogTemplate.js","sources":["../../../screens/DialogTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\nimport { TemplateMetadata } from './TemplateMetadata';\n\n/**\n * A reusable dialog structure — the same idea as a {@link ScreenTemplate}, for content that opens over an\n * application rather than sitting inside it.\n *\n * A dialog has no `fitsSlot` because it occupies no slot: it is an overlay, summoned by something rather\n * than placed by a containing layout. Everything else is the same, which is deliberate — a confirmation\n * dialog and a detail screen are both \"slots with an arrangement, filled with content\", and there is no\n * reason for an author to learn that twice.\n */\nexport interface DialogTemplate {\n    /**\n     * The template's name.\n     */\n    name: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other. Absent for declaration order with\n     * no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — a dialog's own chrome, such as its header\n     * and button bar.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n\n    /** Optional semantic type, browse category and scope restrictions. */\n    metadata?: TemplateMetadata;\n}\n\nexport const DialogTemplatePropertyNames: (keyof DialogTemplate)[] = [\n    'name',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n    'metadata',\n];\n"],"names":["DialogTemplatePropertyNames"],"mappings":"AAAA;AACA;MA0DaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA,WAAA;AACA,IAAA;;;"}

package/dist/esm/screens/ScreenTemplate.d.ts

@@ -1,6 +1,7 @@
 import { SceneElement } from '../elements';
 import { Arrangement, Slot } from '../layouts';
 import { Behavior } from '../interactions';
+import { TemplateMetadata } from './TemplateMetadata';
 export interface ScreenTemplate {
     name: string;
     fitsSlot?: string;
@@ -10,6 +11,7 @@ export interface ScreenTemplate {
     displayName?: string;
     description?: string;
     behaviors?: Behavior[];
+    metadata?: TemplateMetadata;
 }
 export declare const ScreenTemplatePropertyNames: (keyof ScreenTemplate)[];
 //# sourceMappingURL=ScreenTemplate.d.ts.map

package/dist/esm/screens/ScreenTemplate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ScreenTemplate.d.ts","sourceRoot":"","sources":["../../../screens/ScreenTemplate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAiB3C,MAAM,WAAW,cAAc;IAI3B,IAAI,EAAE,MAAM,CAAC;IAMb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAKlB,KAAK,EAAE,IAAI,EAAE,CAAC;IAMd,WAAW,CAAC,EAAE,WAAW,CAAC;IAM1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAKzC,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CAC1B;AAED,eAAO,MAAM,2BAA2B,EAAE,CAAC,MAAM,cAAc,CAAC,EAS/D,CAAC"}
+{"version":3,"file":"ScreenTemplate.d.ts","sourceRoot":"","sources":["../../../screens/ScreenTemplate.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAC/C,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAiBtD,MAAM,WAAW,cAAc;IAI3B,IAAI,EAAE,MAAM,CAAC;IAMb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAKlB,KAAK,EAAE,IAAI,EAAE,CAAC;IAMd,WAAW,CAAC,EAAE,WAAW,CAAC;IAM1B,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,EAAE,CAAC,CAAC;IAKzC,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,WAAW,CAAC,EAAE,MAAM,CAAC;IAKrB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;IAGvB,QAAQ,CAAC,EAAE,gBAAgB,CAAC;CAC/B;AAED,eAAO,MAAM,2BAA2B,EAAE,CAAC,MAAM,cAAc,CAAC,EAU/D,CAAC"}

package/dist/esm/screens/ScreenTemplate.js

@@ -8,7 +8,8 @@ const ScreenTemplatePropertyNames = [
     'content',
     'displayName',
     'description',
-    'behaviors'
+    'behaviors',
+    'metadata'
 ];
 
 export { ScreenTemplatePropertyNames };

package/dist/esm/screens/ScreenTemplate.js.map

@@ -1 +1 @@
-{"version":3,"file":"ScreenTemplate.js","sources":["../../../screens/ScreenTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\n\n/**\n * A reusable screen structure that fills a named slot on whatever contains it, and offers slots of its\n * own for what it contains in turn.\n *\n * A {@link Layout} and a screen template are deliberately different things. A layout is the application's\n * base navigational look — the shell with its top bar, navigation and content region — and an application\n * has one. A screen template is what goes *inside* that shell, and an application has many: one per\n * module, feature or slice that needs a shape of its own.\n *\n * `fitsSlot` is what makes them compose. A module's screen template fits the application layout's content\n * slot; a feature's screen template fits a slot the module's template declares; a slice's fits one the\n * feature's declares. The same rule at every level, so nesting is arbitrarily deep without a second\n * mechanism — and a template always states where it belongs rather than being told by whatever happens to\n * host it.\n */\nexport interface ScreenTemplate {\n    /**\n     * The template's name, which a {@link Screen} refers to.\n     */\n    name: string;\n\n    /**\n     * The name of the slot on the containing {@link Layout} or screen template this one fills, or\n     * undefined for a template that is placed explicitly rather than by declaration.\n     */\n    fitsSlot?: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other — the same shape a {@link Layout}\n     * uses, evaluated by the same engine. Absent for declaration order with no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — the chrome a template brings with it, as\n     * opposed to what a {@link Screen} based on it fills in.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n}\n\nexport const ScreenTemplatePropertyNames: (keyof ScreenTemplate)[] = [\n    'name',\n    'fitsSlot',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n];\n"],"names":["ScreenTemplatePropertyNames"],"mappings":"AAAA;AACA;MAkEaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,UAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA;;;"}
+{"version":3,"file":"ScreenTemplate.js","sources":["../../../screens/ScreenTemplate.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\nimport { SceneElement } from '../elements';\nimport { Arrangement, Slot } from '../layouts';\nimport { Behavior } from '../interactions';\nimport { TemplateMetadata } from './TemplateMetadata';\n\n/**\n * A reusable screen structure that fills a named slot on whatever contains it, and offers slots of its\n * own for what it contains in turn.\n *\n * A {@link Layout} and a screen template are deliberately different things. A layout is the application's\n * base navigational look — the shell with its top bar, navigation and content region — and an application\n * has one. A screen template is what goes *inside* that shell, and an application has many: one per\n * module, feature or slice that needs a shape of its own.\n *\n * `fitsSlot` is what makes them compose. A module's screen template fits the application layout's content\n * slot; a feature's screen template fits a slot the module's template declares; a slice's fits one the\n * feature's declares. The same rule at every level, so nesting is arbitrarily deep without a second\n * mechanism — and a template always states where it belongs rather than being told by whatever happens to\n * host it.\n */\nexport interface ScreenTemplate {\n    /**\n     * The template's name, which a {@link Screen} refers to.\n     */\n    name: string;\n\n    /**\n     * The name of the slot on the containing {@link Layout} or screen template this one fills, or\n     * undefined for a template that is placed explicitly rather than by declaration.\n     */\n    fitsSlot?: string;\n\n    /**\n     * The slots this template offers to whatever it contains, in declaration order.\n     */\n    slots: Slot[];\n\n    /**\n     * How this template's own `slots` position relative to each other — the same shape a {@link Layout}\n     * uses, evaluated by the same engine. Absent for declaration order with no further positioning.\n     */\n    arrangement?: Arrangement;\n\n    /**\n     * Content the template itself provides, keyed by slot name — the chrome a template brings with it, as\n     * opposed to what a {@link Screen} based on it fills in.\n     */\n    content?: Record<string, SceneElement[]>;\n\n    /**\n     * A human-readable name for a template picker, falling back to `name`.\n     */\n    displayName?: string;\n\n    /**\n     * A one-line description for a template picker.\n     */\n    description?: string;\n    /**\n     * The behaviors attached here - what happens when someone interacts with it. Additive with whatever is\n     * attached further out or further in.\n     */\n    behaviors?: Behavior[];\n\n    /** Optional semantic type, browse category and scope restrictions. */\n    metadata?: TemplateMetadata;\n}\n\nexport const ScreenTemplatePropertyNames: (keyof ScreenTemplate)[] = [\n    'name',\n    'fitsSlot',\n    'slots',\n    'arrangement',\n    'content',\n    'displayName',\n    'description',\n    'behaviors',\n    'metadata',\n];\n"],"names":["ScreenTemplatePropertyNames"],"mappings":"AAAA;AACA;MAsEaA,2BAAAA,GAAwD;AACjE,IAAA,MAAA;AACA,IAAA,UAAA;AACA,IAAA,OAAA;AACA,IAAA,aAAA;AACA,IAAA,SAAA;AACA,IAAA,aAAA;AACA,IAAA,aAAA;AACA,IAAA,WAAA;AACA,IAAA;;;"}

package/dist/esm/screens/TemplateMetadata.d.ts

@@ -0,0 +1,14 @@
+export declare enum TemplateScope {
+    Application = "Application",
+    Module = "Module",
+    Feature = "Feature",
+    Subfeature = "Subfeature",
+    Slice = "Slice"
+}
+export interface TemplateMetadata {
+    type?: string;
+    category?: string;
+    scopes?: TemplateScope[];
+}
+export declare const TemplateMetadataPropertyNames: (keyof TemplateMetadata)[];
+//# sourceMappingURL=TemplateMetadata.d.ts.map

package/dist/esm/screens/TemplateMetadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateMetadata.d.ts","sourceRoot":"","sources":["../../../screens/TemplateMetadata.ts"],"names":[],"mappings":"AAIA,oBAAY,aAAa;IACrB,WAAW,gBAAgB;IAC3B,MAAM,WAAW;IACjB,OAAO,YAAY;IACnB,UAAU,eAAe;IACzB,KAAK,UAAU;CAClB;AAMD,MAAM,WAAW,gBAAgB;IAE7B,IAAI,CAAC,EAAE,MAAM,CAAC;IAEd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,MAAM,CAAC,EAAE,aAAa,EAAE,CAAC;CAC5B;AAED,eAAO,MAAM,6BAA6B,EAAE,CAAC,MAAM,gBAAgB,CAAC,EAAmC,CAAC"}

package/dist/esm/screens/TemplateMetadata.js

@@ -0,0 +1,18 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+/** The application hierarchy at which a reusable template is selected. */ var TemplateScope = /*#__PURE__*/ function(TemplateScope) {
+    TemplateScope["Application"] = "Application";
+    TemplateScope["Module"] = "Module";
+    TemplateScope["Feature"] = "Feature";
+    TemplateScope["Subfeature"] = "Subfeature";
+    TemplateScope["Slice"] = "Slice";
+    return TemplateScope;
+}({});
+const TemplateMetadataPropertyNames = [
+    'type',
+    'category',
+    'scopes'
+];
+
+export { TemplateMetadataPropertyNames, TemplateScope };
+//# sourceMappingURL=TemplateMetadata.js.map

package/dist/esm/screens/TemplateMetadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TemplateMetadata.js","sources":["../../../screens/TemplateMetadata.ts"],"sourcesContent":["// Copyright (c) Cratis. All rights reserved.\n// Licensed under the MIT license. See LICENSE file in the project root for full license information.\n\n/** The application hierarchy at which a reusable template is selected. */\nexport enum TemplateScope {\n    Application = 'Application',\n    Module = 'Module',\n    Feature = 'Feature',\n    Subfeature = 'Subfeature',\n    Slice = 'Slice',\n}\n\n/**\n * Optional semantic and browsing metadata. Type and category are open strings so packages can\n * introduce their own vocabulary without a Scene release. Category never determines applicability.\n */\nexport interface TemplateMetadata {\n    /** Semantic role; built-in roles are ApplicationShell, Workspace, List, Detail, Form and Dialog. */\n    type?: string;\n    /** A package-defined browse category, preserved even when the host does not recognize it. */\n    category?: string;\n    /** Explicit scope restriction. Absent uses the structural role; an empty list allows no scope. */\n    scopes?: TemplateScope[];\n}\n\nexport const TemplateMetadataPropertyNames: (keyof TemplateMetadata)[] = ['type', 'category', 'scopes'];\n"],"names":["TemplateScope","TemplateMetadataPropertyNames"],"mappings":"AAAA;AACA;AAEA,2EACO,IAAKA,aAAAA,iBAAAA,SAAAA,aAAAA,EAAAA;;;;;;AAAAA,IAAAA,OAAAA,aAAAA;AAMX,CAAA,CAAA,EAAA;MAeYC,6BAAAA,GAA4D;AAAC,IAAA,MAAA;AAAQ,IAAA,UAAA;AAAY,IAAA;;;"}

package/dist/esm/screens/index.d.ts

@@ -1,4 +1,5 @@
 export * from './Screen';
 export * from './ScreenTemplate';
 export * from './DialogTemplate';
+export * from './TemplateMetadata';
 //# sourceMappingURL=index.d.ts.map

package/dist/esm/screens/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../screens/index.ts"],"names":[],"mappings":"AAGA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../screens/index.ts"],"names":[],"mappings":"AAGA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC"}

package/dist/esm/screens/index.js

@@ -1,4 +1,5 @@
 export * from './Screen';
 export * from './ScreenTemplate';
 export * from './DialogTemplate';
+export * from './TemplateMetadata';
 //# sourceMappingURL=index.js.map

package/dist/esm/screens/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../screens/index.ts"],"names":[],"mappings":"AAGA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../screens/index.ts"],"names":[],"mappings":"AAGA,cAAc,UAAU,CAAC;AACzB,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC"}