@cratis/scene.blueprint.inventory 0.0.0-stage → 4.53.1

package/index.ts

@@ -0,0 +1,14 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+export * from './packageName';
+export * from './templateProvenance';
+export * from './inventoryQueries';
+export * from './inventoryParts';
+export * from './inventoryScreenSet';
+export * from './templates';
+export * from './screens';
+export * from './navigation';
+export * from './manifest';
+export * from './blueprint';
+export * from './inventoryApplication';

package/inventoryApplication.ts

@@ -0,0 +1,28 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { UiProfile } from '@cratis/scene.model';
+import { ApplicationStructureIndex } from '@cratis/scene.engine';
+import { ApplicationDocument, CompositionOptions, defaultLayouts, previewProfile } from '@cratis/scene.blueprint.default';
+import { inventoryNavigation, inventoryStructure } from './navigation';
+import { inventoryScreens } from './screens';
+import { inventoryDialogTemplates, inventoryScreenTemplates } from './templates';
+
+/** The id of the sample-data pack a new application starts with. */
+export const inventoryDefaultSampleDataId = 'inventory-warehouse';
+
+/**
+ * The example application of the blueprint: the foundation's layouts, the Inventory and Assets templates and quick-create dialogs and its eight screens, rendering against the
+ * foundation's packages with the default sample-data pack chosen. This is what a gallery previews and what the conformance fixture
+ * (`Samples/Inventory/inventory.play`) declares in Screenplay: the document, the structure and the navigation are the three things an application is made of.
+ */
+export function inventoryApplication(sampleData: string = inventoryDefaultSampleDataId): ApplicationDocument {
+    const profile: UiProfile = { ...previewProfile(undefined), name: 'Inventory and Assets', sampleData: { activePack: sampleData, mappings: [], bindings: [] } };
+    return { layouts: defaultLayouts, screenTemplates: inventoryScreenTemplates, dialogTemplates: inventoryDialogTemplates, screens: inventoryScreens, uiProfiles: [profile] };
+}
+
+/** What a host composes the screens with: the application's logo, which the shell's topbar shows. */
+export const inventoryComposition: CompositionOptions = { logo: inventoryNavigation.application.logo };
+
+/** The structure and navigation the shell's regions show and the items' destinations resolve against. */
+export const inventoryNavigationModel = () => ({ structure: new ApplicationStructureIndex(inventoryStructure), navigation: inventoryNavigation });

package/inventoryParts.ts

@@ -0,0 +1,52 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import {
+    Behavior, BindingSourceKind, DialogTemplate, ExternalComponent, InteractionActionKind, InteractionTriggerKind, NavigateAction, OpenDialogAction, SceneElement, ScreenTemplate, TemplateMetadata, TemplateScope,
+} from '@cratis/scene.model';
+import { component, panel } from '@cratis/scene.blueprint.default';
+import { inventoryTemplateProvenance } from './templateProvenance';
+
+export { component, panel };
+
+/** The category of every template of this blueprint (spec Part B 1.2: `Business / <domain>`). */
+export const inventoryCategory = 'Business / Inventory';
+
+/** The package-relative thumbnail of a template. */
+export const thumbnailOf = (templateName: string): string => `thumbnails/${templateName}.svg`;
+
+/** The metadata of a screen template of this blueprint: provenance, a type from the vocabulary, the category, a thumbnail and the levels it applies at. */
+export const inventoryMetadata = (name: string, type: 'Dashboard' | 'List' | 'Board' | 'Detail' | 'Form' | 'Dialog' | 'Workspace', scopes: TemplateScope[]): TemplateMetadata =>
+    ({ ...inventoryTemplateProvenance, type, category: inventoryCategory, thumbnail: thumbnailOf(name), scopes });
+
+/** A button of the foundation: a verb, its emphasis, and the permission rule every action declares (spec Part B 1.5). */
+export const actionButton = (id: string, label: string, emphasis: 'primary' | 'secondary' | 'quiet' | 'danger', extra: Record<string, unknown> = {}, behaviors?: Behavior[]): ExternalComponent =>
+    ({ ...component(id, 'actionButton', { label, emphasis, permission: 'enabled', ...extra }), ...(behaviors ? { behaviors } : {}) });
+
+/** What pressing an element does: open the named dialog template over the page. */
+export const opensDialog = (dialogTemplate: string): Behavior[] =>
+    [{ bindings: [{ trigger: { kind: InteractionTriggerKind.Click }, actions: [{ kind: InteractionActionKind.OpenDialog, dialogTemplate } as OpenDialogAction] }] }];
+
+/** What pressing an element does: go to the named screen. */
+export const goesTo = (screen: string): Behavior[] =>
+    [{ bindings: [{ trigger: { kind: InteractionTriggerKind.Click }, actions: [{ kind: InteractionActionKind.Navigate, screen } as NavigateAction] }] }];
+
+/**
+ * What choosing a row of a list does: open the record page, handing it the chosen row's id. The list is single-selection, so choosing a row is
+ * opening it - the way a table of records works everywhere.
+ */
+export const opensRecordOnSelect = (listId: string, screen: string): Behavior[] => [{
+    bindings: [{
+        trigger: { kind: InteractionTriggerKind.Select },
+        actions: [{ kind: InteractionActionKind.Navigate, screen, arguments: [{ name: 'id', value: { kind: BindingSourceKind.ComponentProperty, componentId: listId, path: 'value' } }] } as NavigateAction],
+    }],
+}];
+
+/** What a Cancel or Close control does: close the dialog it was opened from. */
+export const closesDialog = (): Behavior[] => [{ bindings: [{ trigger: { kind: InteractionTriggerKind.Click }, actions: [{ kind: InteractionActionKind.CloseDialog }] }] }];
+
+/** An element with the given behaviors attached. */
+export const withBehaviors = <T extends SceneElement>(element: T, behaviors: Behavior[]): T => ({ ...element, behaviors });
+
+export type InventoryScreenTemplate = ScreenTemplate;
+export type InventoryDialogTemplate = DialogTemplate;

package/inventoryQueries.ts

@@ -0,0 +1,64 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { BindingExpression, BindingSourceKind } from '@cratis/scene.model';
+
+/**
+ * A property taken from a query result - never a value. An Inventory template declares *where* its data comes from and the sample-data pack, or the real
+ * query, supplies the rows (spec SD1); `path` reaches into the result (`0.value` is the first row's `value`, an empty path is the whole result).
+ */
+export const fromQuery = (query: string, path = ''): BindingExpression => ({ kind: BindingSourceKind.QueryResult, query, path });
+
+/** The queries of the dashboard, the pages and the screens that are not a plain list. Each is a shape the sample-data pack supplies rows for. */
+export const InventoryQuery = {
+    /** One row: the `locale` the figures and dates are formatted in and the `currency` of the amounts. */
+    Settings: 'InventorySettings',
+    Kpis: 'InventoryKpis',
+    TopMovers: 'InventoryTopMovers',
+    LowStock: 'InventoryLowStock',
+    RecentMovements: 'RecentMovements',
+    RecordTabs: 'InventoryRecordTabs',
+    LocationNodes: 'LocationNodes',
+    LocationContents: 'LocationContents',
+    LocationContentColumns: 'LocationContentColumns',
+    FormErrors: 'InventoryFormErrors',
+} as const;
+
+/** The Inventory entities a template is made for. */
+export enum InventoryEntityKind {
+    Item = 'Item',
+    Movement = 'Movement',
+    Supplier = 'Supplier',
+}
+
+/** The plural of each entity: the read model (and so the shape) its records are queried from. */
+export const inventoryEntityPlural: Record<InventoryEntityKind, string> = {
+    [InventoryEntityKind.Item]: 'Items',
+    [InventoryEntityKind.Movement]: 'Movements',
+    [InventoryEntityKind.Supplier]: 'Suppliers',
+};
+
+/**
+ * The queries one entity's templates bind to, named from the entity so a template never spells one out: the records, the columns and filter fields of the
+ * list, its saved views and column choices, the selection, the sections of the full and the quick form, and the record the page shows.
+ */
+export const inventoryQueriesOf = (entity: InventoryEntityKind) => ({
+    rows: inventoryEntityPlural[entity],
+    columns: `${entity}Columns`,
+    filterFields: `${entity}FilterFields`,
+    views: `${entity}Views`,
+    columnChoices: `${entity}ColumnChoices`,
+    selection: `${entity}Selection`,
+    sections: `${entity}Sections`,
+    quickSections: `${entity}QuickSections`,
+    record: `${entity}Record`,
+    summary: `${entity}Summary`,
+    stockByLocation: `${entity}StockByLocation`,
+    movements: `${entity}Movements`,
+    activity: `${entity}Activity`,
+    tasks: `${entity}Tasks`,
+});
+
+/** The locale and currency of the data, bound onto every component that formats a figure or a date. */
+export const localeOfData = { locale: fromQuery(InventoryQuery.Settings, '0.locale') };
+export const currencyOfData = { ...localeOfData, currency: fromQuery(InventoryQuery.Settings, '0.currency') };

package/inventoryScreenSet.ts

@@ -0,0 +1,25 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { BlueprintScreen } from '@cratis/scene.model';
+
+/** One ready-to-use screen: the qualified name that is also its place in the application (`inventory.items.record` is the `record` feature of `items` in the `inventory` module). */
+export interface InventoryScreenDefinition extends BlueprintScreen {
+    template: string;
+    description: string;
+}
+
+/**
+ * The screens the blueprint brings, in navigation order. This one list is what the manifest's screen set, the `Screen` instances, the application structure
+ * and the navigation are all derived from, so they cannot disagree about which screens exist or where they sit.
+ */
+export const inventoryScreenDefinitions: InventoryScreenDefinition[] = [
+    { name: 'inventory.dashboard', title: 'Dashboard', template: 'InventoryDashboard', order: 0, description: 'Low stock, stock value, top movers and recent movements.' },
+    { name: 'inventory.items', title: 'Items', template: 'InventoryItemList', order: 1, description: 'Every item with its stock, low stock highlighted.' },
+    { name: 'inventory.items.gallery', title: 'Item gallery', template: 'InventoryItemGallery', parent: 'inventory.items', order: 0, description: 'Every item as a card with its picture.' },
+    { name: 'inventory.items.record', title: 'Item', template: 'InventoryItemPage', parent: 'inventory.items', description: 'One item with its stock by location, movement history and supplier.' },
+    { name: 'inventory.locations', title: 'Locations', template: 'InventoryLocations', order: 2, description: 'The location tree beside what is stored in the chosen location.' },
+    { name: 'inventory.movements', title: 'Movements', template: 'InventoryMovementList', order: 3, description: 'Every check in, check out, transfer and adjustment.' },
+    { name: 'inventory.movements.check', title: 'Check in or out', template: 'InventoryCheckInOut', parent: 'inventory.movements', description: 'Scan or search an item and check it in or out, from a phone.' },
+    { name: 'inventory.suppliers', title: 'Suppliers', template: 'InventorySupplierList', order: 4, description: 'The suppliers items are bought from.' },
+];

package/manifest.ts

@@ -0,0 +1,41 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { PackageKind, ScenePackage } from '@cratis/scene.model';
+import { inventoryBlueprintName } from './packageName';
+import { inventoryScreenDefinitions } from './inventoryScreenSet';
+import { inventoryDialogTemplates, inventoryScreenTemplates } from './templates';
+
+const description = 'Items, locations, movements and suppliers for a warehouse: a dashboard, item lists and cards, item pages, a location tree, stock adjustment and check in and out.';
+
+/**
+ * This blueprint's declaration. A domain blueprint depends on the foundation set (`Cratis.Blueprint.Default`) and reuses its layouts, slots,
+ * components and themes - it ships none of its own - and adds what is specific to the domain: templates, a ready-to-use screen set, sample data
+ * and thumbnails. The package `version` is the blueprint's version: it is what a template reference pins and what "update available" compares.
+ */
+export const inventoryBlueprintManifest: ScenePackage = {
+    name: inventoryBlueprintName,
+    version: '1.0.0',
+    kind: PackageKind.Blueprint,
+    dependencies: [{ name: 'Cratis.Blueprint.Default', versionRange: '^1.0.0' }],
+    components: [],
+    layouts: [],
+    screenTemplates: inventoryScreenTemplates.map(template => template.name),
+    dialogTemplates: inventoryDialogTemplates.map(template => template.name),
+    themes: [],
+    displayName: 'Inventory and Assets',
+    description,
+    module: '@cratis/scene.blueprint.inventory',
+    license: 'MIT',
+    licenseUrl: 'https://github.com/Cratis/Scene/blob/main/LICENSE',
+    sampleData: [{ id: 'inventory-warehouse', title: 'Inventory · Warehouse', locale: 'en-GB', path: 'sampleData/inventory-warehouse.json' }],
+    blueprint: {
+        domain: 'inventory',
+        description,
+        thumbnail: 'thumbnails/inventory.svg',
+        screenSet: inventoryScreenDefinitions.map(({ name, title, description: screenDescription, template, parent, order }) => ({
+            name, title, description: screenDescription, template, ...(parent === undefined ? {} : { parent }), ...(order === undefined ? {} : { order }),
+        })),
+        defaultSampleData: 'inventory-warehouse',
+    },
+};

package/navigation.ts

@@ -0,0 +1,60 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { ApplicationStructure, NavigationModel, NavigationRegionKind, NavigationRegionMode } from '@cratis/scene.model';
+import { inventoryScreenDefinitions } from './inventoryScreenSet';
+
+/** The module the blueprint's screens live in, and so the first segment of every screen's qualified name. */
+export const inventoryModule = 'inventory';
+
+/**
+ * The application structure the screen set implies: one module, `inventory`, a feature for each screen and the sub-features beneath it (`inventory.items.record` is the
+ * `record` feature of `items`). Derived from the screen names, so a screen added to the set is part of the structure without a second edit.
+ */
+export const inventoryStructure: ApplicationStructure = (() => {
+    interface Node { id: string; name: string; features: Node[]; slices: never[] }
+    const root: Node = { id: inventoryModule, name: 'Inventory', features: [], slices: [] };
+    for (const screen of inventoryScreenDefinitions) {
+        let parent = root;
+        for (const id of screen.name.split('.').slice(1)) {
+            let node = parent.features.find(candidate => candidate.id === id);
+            if (!node) {
+                node = { id, name: screen.title, features: [], slices: [] };
+                parent.features.push(node);
+            }
+            parent = node;
+        }
+    }
+
+    return { modules: [{ id: root.id, name: root.name, features: root.features }] } as unknown as ApplicationStructure;
+})();
+
+/**
+ * The navigation of the application the blueprint is: the topbar names the module, and the module's sidebar - which overrides the application's - lists
+ * the five places a warehouse goes: Dashboard, Items (with the table and the gallery beneath it), Locations, Movements and Suppliers.
+ */
+export const inventoryNavigation: NavigationModel = {
+    application: {
+        logo: { image: '', title: 'Inventory' },
+        regions: [{ region: NavigationRegionKind.Topbar, items: [{ id: 'inventory', title: 'Inventory', target: { module: inventoryModule } }] }],
+    },
+    modules: [{
+        module: inventoryModule,
+        regions: [{
+            region: NavigationRegionKind.Sidebar,
+            mode: NavigationRegionMode.Override,
+            items: [
+                { id: 'dashboard', title: 'Dashboard', target: { module: inventoryModule, feature: 'dashboard' } },
+                {
+                    id: 'items', title: 'Items', target: { module: inventoryModule, feature: 'items' }, children: [
+                        { id: 'item-table', title: 'Table', target: { module: inventoryModule, feature: 'items' } },
+                        { id: 'item-gallery', title: 'Gallery', target: { module: inventoryModule, feature: 'items.gallery' } },
+                    ],
+                },
+                { id: 'locations', title: 'Locations', target: { module: inventoryModule, feature: 'locations' } },
+                { id: 'movements', title: 'Movements', target: { module: inventoryModule, feature: 'movements' } },
+                { id: 'suppliers', title: 'Suppliers', target: { module: inventoryModule, feature: 'suppliers' } },
+            ],
+        }],
+    }],
+};

package/package.json

@@ -1,6 +1,80 @@
 {
-  "name": "@cratis/scene.blueprint.inventory",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+    "name": "@cratis/scene.blueprint.inventory",
+    "version": "4.53.1",
+    "description": "Items, locations, movements and suppliers for a warehouse.",
+    "keywords": [
+        "cratis",
+        "scene",
+        "react",
+        "ui",
+        "blueprint",
+        "inventory"
+    ],
+    "author": "Cratis",
+    "license": "MIT",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Cratis/Scene.git"
+    },
+    "publishConfig": {
+        "access": "public"
+    },
+    "files": [
+        "dist",
+        "sampleData",
+        "thumbnails",
+        "blueprintCatalog.json",
+        "**/*.ts",
+        "**/*.tsx",
+        "!**/for_*/**"
+    ],
+    "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",
+        "test:browser": "yarn g:test --config ./vitest.browser.config.mts",
+        "ci": "yarn g:ci",
+        "up": "yarn g:up"
+    },
+    "dependencies": {
+        "@cratis/scene.blueprint.default": "4.53.1",
+        "@cratis/scene.engine": "4.53.1",
+        "@cratis/scene.model": "4.53.1",
+        "@cratis/scene.react": "4.53.1"
+    },
+    "devDependencies": {
+        "@cratis/scene.blueprint.default": "4.53.1",
+        "@cratis/scene.engine": "4.53.1",
+        "@cratis/scene.model": "4.53.1",
+        "@cratis/scene.react": "4.53.1",
+        "@primereact/core": "11.2.0",
+        "@primereact/headless": "11.2.0",
+        "primeicons": "8.0.2",
+        "primereact": "11.2.0",
+        "react": "^19.3.0",
+        "react-dom": "^19.3.0"
+    },
+    "peerDependencies": {
+        "@cratis/components": "^4.1.1",
+        "@primereact/core": "^11.0.0",
+        "@primereact/headless": "^11.0.0",
+        "primeicons": "^8.0.0",
+        "primereact": "^11.0.0",
+        "react": "^19.0.0",
+        "react-dom": "^19.0.0"
+    }
 }

package/packageName.ts

@@ -0,0 +1,5 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+/** The name this blueprint is known by inside a `ui profile`; every component registry key is built from it. */
+export const inventoryBlueprintName = 'Cratis.Blueprint.Inventory';