@rokkit/core 1.0.0-next.113 → 1.0.0-next.115

package/dist/packages/tutorial/src/files.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Recursively get files in a folder that match the given pattern.
+ * @param {string} folderPath - The folder to search in.
+ * @param {RegExp} pattern - The pattern to match the file names.
+ * @param {string} [dir=''] - The current directory, used for recursion.
+ * @returns {Promise<Array<import('./types').FileMetadata>>} - An array of matched files.
+ */
+export function getFiles(folderPath: string, pattern?: RegExp, dir?: string): Promise<Array<import("./types").FileMetadata>>;

package/dist/packages/tutorial/src/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./types";
+export { assimilateTutorials } from "./assimilate.js";

package/dist/packages/tutorial/src/metadata/base.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Base class for reading story metadata from files
+ * @abstract
+ */
+export class BaseMetadataReader {
+    /**
+     * @param {string} filePath - Path to the file containing metadata
+     * @throws {Error} If filePath is not provided or empty
+     */
+    constructor(filePath: string);
+    filePath: string;
+    /**
+     * Reads metadata from the file
+     * @abstract
+     * @returns {Promise<object>} Story metadata
+     * @throws {Error} If not implemented by child class
+     */
+    read(): Promise<object>;
+}

package/dist/packages/tutorial/src/metadata/factory.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Factory for creating story metadata readers
+ */
+export class MetadataFactory {
+    /**
+     * @param {MetadataRegistry} registry - Registry of metadata readers
+     * @throws {Error} If registry is not provided
+     */
+    constructor(registry: MetadataRegistry);
+    registry: MetadataRegistry;
+    /**
+     * Creates a metadata reader for the given file type
+     * @param {string} filePath - Path to the file
+     * @returns {import('./base.js').BaseMetadataReader} A metadata reader instance
+     * @throws {Error} If no reader found for file type or if filePath is not provided
+     */
+    create(filePath: string): import("./base.js").BaseMetadataReader;
+}
+import { MetadataRegistry } from './registry.js';

package/dist/packages/tutorial/src/metadata/index.d.ts

@@ -0,0 +1,2 @@
+export const factory: MetadataFactory;
+import { MetadataFactory } from './factory.js';

package/dist/packages/tutorial/src/metadata/javascript.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reads story metadata from JavaScript files
+ * @extends BaseMetadataReader
+ */
+export class JavaScriptMetadata extends BaseMetadataReader {
+}
+import { BaseMetadataReader } from './base.js';

package/dist/packages/tutorial/src/metadata/json.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reads story metadata from JSON files
+ * @extends BaseMetadataReader
+ */
+export class JsonMetadata extends BaseMetadataReader {
+}
+import { BaseMetadataReader } from './base.js';

package/dist/packages/tutorial/src/metadata/markdown.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reads story metadata from Markdown files using frontmatter
+ * @extends BaseMetadataReader
+ */
+export class MarkdownMetadata extends BaseMetadataReader {
+}
+import { BaseMetadataReader } from './base.js';

package/dist/packages/tutorial/src/metadata/registry.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Registry for story metadata readers
+ */
+export class MetadataRegistry {
+    /**
+     * Register a metadata reader for a file type
+     * @param {string} fileType - The file type (extension)
+     * @param {typeof BaseMetadataReader} ReaderClass - The metadata reader class
+     * @throws {Error} If reader class is invalid
+     */
+    register(fileType: string, ReaderClass: typeof BaseMetadataReader): void;
+    /**
+     * Get a metadata reader for a file type
+     * @param {string} fileType - The file type (extension)
+     * @returns {typeof BaseMetadataReader|undefined} The metadata reader class or undefined if not found
+     */
+    getReader(fileType: string): typeof BaseMetadataReader | undefined;
+    /**
+     * Check if a reader exists for a file type
+     * @param {string} fileType - The file type (extension)
+     * @returns {boolean} True if a reader exists
+     */
+    hasReader(fileType: string): boolean;
+    #private;
+}
+import { BaseMetadataReader } from './base.js';

package/dist/packages/tutorial/src/metamodel.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Fetches the content of the modules.
+ *
+ * @param {Object} modules - The modules to fetch the content from.
+ * @returns {Promise<Array>} - The content of the modules.
+ */
+export function fetchImports(modules: Object): Promise<any[]>;
+/**
+ * Adds metadata to the files.
+ *
+ * @param {Array} files - The files to add metadata to.
+ * @returns {Array} - The files with metadata.
+ */
+export function addPathMetadata(files: any[]): any[];
+/**
+ * Adds metadata to the module
+ *
+ * @param {*} modules
+ * @param {import('./types.js').TutorialOptions} options
+ * @returns
+ */
+export function addModuleMetadata(modules: any, options: import("./types.js").TutorialOptions): any;
+/**
+ * Recursively add part and its children to the data object.
+ *
+ * @param {Object} data - The data object to add the part to.
+ * @param {Object} item - The item containing the part information.
+ * @param {number} index - The index of the part in the item's parts array.
+ * @returns {Object} - The updated data object.
+ */
+export function tutorialsToNestedObject(data: Object, item: Object, index?: number): Object;
+/**
+ * Converts an array of files to a folder hierarchy.
+ *
+ * @param {Array} files - The files to convert to a folder hierarchy.
+ * @returns {Object} - The folder hierarchy.
+ */
+export function convertFilesToFolderHierarchy(tutorials: any, options: any): Object;
+/**
+ * Extracts all thr routes from the folder hierarchy and returns them as an array.
+ *
+ * @param {Array} files - The files to convert to a folder hierarchy.
+ * @returns {Array<string>} - array of route paths
+ */
+export function generateRouteEntries(input: any): Array<string>;

package/dist/packages/tutorial/src/tutorial.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Convert a data object to a sorted hierarchy.
+ * @param {Object} data - The data object to convert.
+ * @param {Object} [fields={}] - The fields used for creating the hierarchy.
+ * @returns {Array} - An array of sorted hierarchical data.
+ */
+export function toSortedHierarchy(data: Object, fields?: Object): any[];
+/**
+ * Get the tutorial by the given route.
+ * @param {Object} tutorials - The tutorials data.
+ * @param {Array<string>} route - The route to find the tutorial by.
+ * @returns {Object|null} - The found tutorial or null if not found.
+ */
+export function findTutorial(tutorials: Object, route: Array<string>): Object | null;
+/**
+ * Get the tutorial by the route and fetch all files under the folders specified by solutionFolder and partialFolder.
+ * @param {TutorialOptions} options - The options for getting the tutorial.
+ * @param {string} route - The route of the tutorial to get.
+ * @returns {Promise<Object|null>} - A promise that resolves to the tutorial with file content or null if not found.
+ */
+export function getTutorials(options: TutorialOptions): Promise<Object | null>;

package/dist/packages/tutorial/src/types.d.ts

@@ -0,0 +1,172 @@
+declare const _default: {};
+export default _default;
+export type Extractors = {
+    /**
+     * - Function to extract metadata from JavaScript files.
+     */
+    js: (arg0: string) => Promise<any>;
+    /**
+     * - Function to extract metadata from JSON files.
+     */
+    json: (arg0: string) => Promise<any>;
+    /**
+     * - Function to extract metadata from Markdown files.
+     */
+    md: (arg0: string) => Promise<any>;
+};
+export type StoryFile = {
+    file: string;
+    fileName: string;
+    folder: string;
+    pageNumber: string;
+    code?: string | undefined;
+    preview?: any;
+    notes?: any;
+};
+export type SampleWithCode = {
+    file: string;
+    code: string;
+    language: string;
+};
+export type StoryPage = {
+    files: Array<SampleWithCode>;
+    preview: any;
+    notes: any;
+    metadata: {
+        [x: string]: any;
+    };
+};
+export type ComponentStory = {
+    name: string;
+    metadata?: {
+        [x: string]: any;
+    } | undefined;
+    pages: Array<StoryPage>;
+};
+export type Stories = {
+    [x: string]: ComponentStory;
+};
+export type StoryOptions = {
+    /**
+     * - filename to render the preview component
+     */
+    preview: string;
+    /**
+     * - filename to render the notes component
+     */
+    notes: string;
+    /**
+     * - filename containing component metadata
+     */
+    metadata: string;
+};
+export type TutorialOptions = {
+    /**
+     * - The root folder containing tutorial files.
+     */
+    rootFolder: string;
+    /**
+     * - The optional filename for metadata, defaults to 'meta.json'.
+     */
+    metadataFilename?: string | undefined;
+    /**
+     * - The optional filename for the readme, defaults to 'README.md'.
+     */
+    readmeFilename?: string | undefined;
+    /**
+     * - The optional filename for the preview, defaults to 'App.svelte'.
+     */
+    previewFilename?: string | undefined;
+    /**
+     * - The folder containing partial example.
+     */
+    partialFolder?: string | undefined;
+    /**
+     * - The folder containing correct example.
+     */
+    solutionFolder?: string | undefined;
+    /**
+     * - The filename to write the hierarchical data.
+     */
+    tutorialMetadata?: string | undefined;
+};
+export type FileMetadata = {
+    /**
+     * - The name of the file.
+     */
+    name: string;
+    /**
+     * - The path to the file.
+     */
+    path: string;
+    /**
+     * - The type of file.
+     */
+    type: string;
+    /**
+     * - The content of the file.
+     */
+    content?: string | undefined;
+    /**
+     * - Contains files in sub folder if the type is 'folder'.
+     */
+    children?: FileMetadata[] | undefined;
+};
+export type SourceContent = {
+    /**
+     * - Svelte component for previewing the example.
+     */
+    preview: any;
+    /**
+     * - Metadata including source for the example.
+     */
+    files: Array<FileMetadata>;
+};
+export type TutorialMetadata = {
+    /**
+     * - The title of the tutorial.
+     */
+    title: string;
+    /**
+     * - The sequence of the tutorial.
+     */
+    sequence: number;
+    /**
+     * - Key used for identifying the tutorial.
+     */
+    key: string;
+    /**
+     * - The route to the tutorial.
+     */
+    route: string;
+    /**
+     * - The readme content as a svelte component.
+     */
+    readme: any;
+    /**
+     * - The app preview as a svelte component.
+     */
+    preview: any;
+    /**
+     * - Contains preview and source files for partial example
+     */
+    pre?: SourceContent | undefined;
+    /**
+     * - Contains preview and source files for completed example.
+     */
+    src?: SourceContent | undefined;
+    /**
+     * - Contains metadata for sub tutorials.
+     */
+    children?: TutorialMetadata[] | undefined;
+};
+export type TutorialData = {
+    /**
+     * - The metadata for the tutorials.
+     */
+    tutorials: Array<TutorialMetadata>;
+    /**
+     * - List of routes for the tutorials.
+     */
+    routes: Array<string>;
+};

package/dist/packages/tutorial/src/utils.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Converts a flat array of file metadata into a nested array of file metadata.
+ *
+ * @param {Array<import('../../rokkit/packages/tutorial/src/types.js').FileMetadata>} files - Flat Array of file metadata
+ * @returns {Array<import('../../rokkit/packages/tutorial/src/types.js').FileMetadata>} - Nested Array of file metadata
+ */
+export function folderHierarchy(files: Array<any>): Array<any>;
+/**
+ * Get the sequence and key from a text string.
+ * @param {string} text - The text to extract the sequence and key from.
+ * @returns {Object|null} - An object containing the sequence and key or null if not found.
+ */
+export function getSequenceAndKey(text: string): Object | null;

package/dist/packages/ui/src/constants.d.ts

@@ -0,0 +1,2 @@
+export const defaultMapping: FieldMapper;
+import { FieldMapper } from '@rokkit/core';

package/dist/packages/ui/src/index.d.ts

@@ -0,0 +1,42 @@
+export * from "./types.js";
+export { default as Button } from "./Button.svelte";
+export { default as Icon } from "./Icon.svelte";
+export { default as Item } from "./Item.svelte";
+export { default as Pill } from "./Pill.svelte";
+export { default as ProgressBar } from "./ProgressBar.svelte";
+export { default as Separator } from "./Separator.svelte";
+export { default as Connector } from "./Connector.svelte";
+export { default as RangeTick } from "./RangeTick.svelte";
+export { default as RangeSlider } from "./RangeSlider.svelte";
+export { default as Node } from "./Node.svelte";
+export { default as Summary } from "./Summary.svelte";
+export { default as BreadCrumbs } from "./BreadCrumbs.svelte";
+export { default as Rating } from "./Rating.svelte";
+export { default as RangeMinMax } from "./RangeMinMax.svelte";
+export { default as Range } from "./Range.svelte";
+export { default as RadioGroup } from "./RadioGroup.svelte";
+export { default as CheckBox } from "./CheckBox.svelte";
+export { default as Calendar } from "./Calendar.svelte";
+export { default as ValidationReport } from "./ValidationReport.svelte";
+export { default as ResponsiveGrid } from "./ResponsiveGrid.svelte";
+export { default as Toggle } from "./Toggle.svelte";
+export { default as Switch } from "./Switch.svelte";
+export { default as List } from "./List.svelte";
+export { default as Accordion } from "./Accordion.svelte";
+export { default as Tree } from "./Tree.svelte";
+export { default as Tabs } from "./Tabs.svelte";
+export { default as Select } from "./Select.svelte";
+export { default as MultiSelect } from "./MultiSelect.svelte";
+export { default as DropDown } from "./DropDown.svelte";
+export { default as Table } from "./TreeTable.svelte";
+export { default as ToggleThemeMode } from "./ToggleThemeMode.svelte";
+export { default as Overlay } from "./Overlay.svelte";
+export { default as Message } from "./Message.svelte";
+export { default as SlidingColumns } from "./SlidingColumns.svelte";
+export { default as InputField } from "./input/InputField.svelte";
+export { default as Form } from "./Form.svelte";
+export { default as FieldLayout } from "./FieldLayout.svelte";
+export { default as DataEditor } from "./DataEditor.svelte";
+export { default as NestedEditor } from "./NestedEditor.svelte";
+export { default as Stepper } from "./Stepper.svelte";
+export { default as ProgressDots } from "./ProgressDots.svelte";

package/dist/packages/ui/src/input/types.d.ts

@@ -0,0 +1,9 @@
+export namespace types {
+    export let string: any;
+    export let integer: any;
+    export { CheckBox as boolean };
+    export { InputSelect as enum };
+    export let phone: any;
+}
+import CheckBox from '../CheckBox.svelte';
+import InputSelect from './InputSelect.svelte';

package/dist/packages/ui/src/lib/fields.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Find an attribute in a schema by path
+ * @param {string} scope
+ * @param {import('../types').DataSchema} schema
+ * @returns {import('../types').LayoutSchema}
+ * @throws {Error} Invalid path
+ */
+export function findAttributeByPath(scope: string, schema: import("../types").DataSchema): import("../types").LayoutSchema;
+/**
+ * Get combined schema and layout
+ * @param {*} data
+ * @param {import('../types').DataSchema} schema
+ * @param {import('../types').LayoutSchema} layout
+ * @returns {import('../types').LayoutSchema}
+ */
+export function getSchemaWithLayout(schema: import("../types").DataSchema, layout: import("../types").LayoutSchema): import("../types").LayoutSchema;

package/dist/packages/ui/src/lib/form.d.ts

@@ -0,0 +1,95 @@
+export namespace messages {
+    let required: string;
+    let email: string;
+    let url: string;
+    let color: string;
+    let number: string;
+    let min: string;
+    let max: string;
+    let pattern: string;
+    let exclusiveMin: string;
+    let exclusiveMax: string;
+    let minLength: string;
+    let maxLength: string;
+    let minItems: string;
+    let maxItems: string;
+    let uniqueItems: string;
+    let contains: string;
+    let exclude: string;
+    let integer: string;
+}
+export namespace dataTypes {
+    export namespace integer_1 {
+        let editor: string;
+        namespace props {
+            let type: string;
+            let step: number;
+        }
+        let availableProps: string[];
+    }
+    export { integer_1 as integer };
+    export namespace number_1 {
+        let editor_1: string;
+        export { editor_1 as editor };
+        export namespace props_1 {
+            let type_1: string;
+            export { type_1 as type };
+            let step_1: number;
+            export { step_1 as step };
+        }
+        export { props_1 as props };
+        let availableProps_1: string[];
+        export { availableProps_1 as availableProps };
+    }
+    export { number_1 as number };
+    export namespace range {
+        let editor_2: string;
+        export { editor_2 as editor };
+        export namespace props_2 {
+            let type_2: string;
+            export { type_2 as type };
+        }
+        export { props_2 as props };
+    }
+    export let string: {
+        default: string;
+        text: string;
+        password: string;
+        email: string;
+        url: string;
+        tel: string;
+        date: string;
+        'datetime-local': string;
+        time: string;
+        week: string;
+        month: string;
+        file: string;
+        hidden: string;
+        color: string;
+        colorpicker: string;
+    };
+    export namespace _enum {
+        let _default: string;
+        export { _default as default };
+        export let select: string;
+        export let radio: string;
+    }
+    export { _enum as enum };
+    export namespace boolean {
+        let _default_1: string;
+        export { _default_1 as default };
+        export let checkbox: string;
+        let _switch: string;
+        export { _switch as switch };
+        let radio_1: string;
+        export { radio_1 as radio };
+    }
+    export namespace array {
+        let _default_2: string;
+        export { _default_2 as default };
+    }
+    export namespace object {
+        let _default_3: string;
+        export { _default_3 as default };
+    }
+}

package/dist/packages/ui/src/lib/index.d.ts

@@ -0,0 +1,6 @@
+export { addRootNode } from "./tree";
+export { deriveSchemaFromValue } from "./schema";
+export { deriveLayoutFromValue } from "./layout";
+export { messages, dataTypes } from "./form";
+export { getSchemaWithLayout, findAttributeByPath } from "./fields";
+export { deriveNestedSchema, flattenAttributes, flattenObject, flattenElement, generateIndex, generateTreeTable } from "./nested";

package/dist/packages/ui/src/lib/layout.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Derives a layout from a given value.
+ * @param {any} value
+ * @param {string} scope
+ * @returns {import('../types').DataLayout}
+ */
+export function deriveLayoutFromValue(value: any, scope?: string): import("../types").DataLayout;

package/dist/packages/ui/src/lib/nested.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Flattens an object into a flat object
+ *
+ * @param {Object} input - The object to flatten
+ * @param {String} scope - The scope of the object
+ */
+export function flattenObject(input: Object, scope?: string): any;
+/**
+ * Flattens an object into an array of key-value pairs
+ *
+ * @param {Object} input - The object to flatten
+ * @param {String} scope - The scope of the object
+ */
+export function flattenAttributes(input: Object, scope?: string): {
+    key: string;
+    value: any;
+    type: string;
+    scope: string;
+}[];
+/**
+ * Derives a nested schema from an object
+ *
+ * @param {Object} input - The object to derive the schema from
+ * @param {String} scope - The scope of the object
+ * @returns {Object} The derived schema
+ */
+export function deriveNestedSchema(input: Object, scope?: string): Object;
+/**
+ * Flattens an element into a flat object
+ *
+ * @param {Object} element - The element to flatten
+ */
+export function flattenElement(element: Object): any;
+/**
+ * Generates an index array referencing the input data
+ *
+ * @param {Object} data - The flat object to index
+ * @param {String} key - The key to use as index
+ */
+export function generateIndex(data: Object, key?: string): any;
+/**
+ * Generates a tree table from the input data
+ *
+ * @param {Object} data - The data to generate the tree table from
+ * @param {String} key - The key to use as index
+ * @param {Boolean} ellipsis - Whether to truncate the value
+ */
+export function generateTreeTable(data: Object, key?: string, ellipsis?: boolean): any;

package/dist/packages/ui/src/lib/schema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Derives a schema from a given value.
+ *
+ * @param {any} data
+ * @returns {import('../types').DataSchema}
+ */
+export function deriveSchemaFromValue(data: any): import("../types").DataSchema;

package/dist/packages/ui/src/lib/select.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Get the optimal position for the list based on anchor and viewport dimensions.
+ *
+ * @param {HTMLElement} anchor - The anchor element to position the list relative to.
+ * @param {HTMLElement} viewport - The viewport element that determines the position.
+ * @returns {string} - A string with CSS position properties and values.
+ */
+export function getListPosition(anchor: HTMLElement, viewport: HTMLElement): string;

package/dist/packages/ui/src/lib/tree.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Adds a root node to the items array converting it into a nested tree with one root node
+ *
+ * @param {Array<Object>} items
+ * @param {string} root
+ * @param {import('@rokkit/core').FieldMapping} fields
+ * @returns
+ */
+export function addRootNode(items: Array<Object>, root?: string, mapping?: import("@rokkit/core").FieldMapper): Object[];

package/dist/packages/ui/src/types.d.ts

@@ -0,0 +1,5 @@
+export type NodeStateIcons = {
+    opened: string;
+    closed: string;
+};
+export type ConnectionType = "empty" | "last" | "child" | "sibling";

package/dist/packages/ui/src/wrappers/index.d.ts

@@ -0,0 +1,3 @@
+export { default as Wrapper } from "./Wrapper.svelte";
+export { default as Section } from "./Section.svelte";
+export { default as Category } from "./Category.svelte";

package/dist/sites/learn/src/hooks.d.ts

@@ -0,0 +1 @@
+export const reroute: any;

package/dist/sites/learn/src/hooks.server.d.ts

@@ -0,0 +1,2 @@
+/** @type {import('@sveltejs/kit').Handle} */
+export const handle: import("@sveltejs/kit").Handle;

package/dist/sites/learn/src/lib/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Finds an item in the menu based on the URL.
+ * @param {Array<any>} menu
+ * @param {*} url
+ * @returns {any}
+ */
+export function findItemInMenu(menu: Array<any>, url: any): any;