xml-model 1.3.0 → 1.3.2

package/dist/node_modules/typescript-rtti/dist.esm/lib/sealed.js

@@ -1,13 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function Sealed() {
-  return (target) => {
-    Object.seal(target);
-    return target;
-  };
-}
-__name(Sealed, "Sealed");
-export {
-  Sealed
-};
-//# sourceMappingURL=sealed.js.map

package/dist/types.js

@@ -1,2 +0,0 @@
-
-//# sourceMappingURL=types.js.map

package/vite/dist/src/class-names.test.d.ts

@@ -1,9 +0,0 @@
-export declare class Book {
-    name: string;
-    nbPages: number;
-    constructor(options: {
-        name: string;
-        nbPages: number;
-    });
-}
-//# sourceMappingURL=class-names.test.d.ts.map

package/vite/dist/src/defaults.d.ts

@@ -1,15 +0,0 @@
-import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext, XMLModelPropertyOptions, XMLModel } from './model/types';
-import { XMLElement, XMLRoot } from './types';
-interface Defaults {
-    fromXML<T>(context: fromXMLContext<T>): T;
-    propertySourceElementsFilter<T>(...args: Parameters<XMLModelPropertyOptions<T>["isSourceElement"]>): boolean;
-    propertyResolveSourceElements<T>(context: Omit<PropertyFromXMLContext<T>, "elements">): XMLElement[];
-    propertyFromXML<T>(context: PropertyFromXMLContext<T>): T[keyof T];
-    toXML<T>(context: toXMLContext<T>): XMLRoot;
-    tagnameFromModel: (model: XMLModel) => string;
-    tagnameFromProperty<T>(property: XMLModelPropertyOptions<T>): string;
-    propertyToXML<T>(context: PropertyToXMLContext<T>): XMLRoot;
-}
-export declare const defaults: Defaults;
-export {};
-//# sourceMappingURL=defaults.d.ts.map

package/vite/dist/src/errors.d.ts

@@ -1,24 +0,0 @@
-import { fromXMLContext, PropertyFromXMLContext, PropertyToXMLContext, toXMLContext } from './model/types';
-export declare class FromXMLConversionError<T> extends Error {
-    context: Omit<fromXMLContext<T>, "properties">;
-    error: unknown;
-    name: string;
-    constructor(context: Omit<fromXMLContext<T>, "properties">, error: unknown);
-}
-export declare class PropertyFromXMLConversionError<T> extends FromXMLConversionError<T> {
-    propertyContext: PropertyFromXMLContext<T>;
-    name: string;
-    constructor(context: Omit<fromXMLContext<T>, "properties">, propertyContext: PropertyFromXMLContext<T>, error: unknown);
-}
-export declare class ToXMLConversionError<T> extends Error {
-    context: Omit<toXMLContext<T>, "properties">;
-    cause: unknown;
-    name: string;
-    constructor(context: Omit<toXMLContext<T>, "properties">, cause: unknown);
-}
-export declare class PropertyToXMLConversionError<T> extends ToXMLConversionError<T> {
-    propertyContext: PropertyToXMLContext<T>;
-    name: string;
-    constructor(context: Omit<toXMLContext<T>, "properties">, propertyContext: PropertyToXMLContext<T>, cause: unknown);
-}
-//# sourceMappingURL=errors.d.ts.map

package/vite/dist/src/index.d.ts

@@ -1,8 +0,0 @@
-import { default as XML } from './xml';
-export type { XMLElement, XMLRoot, Constructor } from './types';
-export { defaults } from './defaults';
-export { getModel, createModel, Model, Prop } from './model';
-export * from './errors';
-export * from 'typescript-rtti';
-export { XML };
-//# sourceMappingURL=index.d.ts.map

package/vite/dist/src/middleware.d.ts

@@ -1,10 +0,0 @@
-export type Middleware<C, T> = (context: C, next: () => T) => T;
-interface ChainableOptions<C, T> {
-    parent: ChainableOptions<C, T> | null;
-    middlewares: Middleware<C, T>[];
-}
-export declare function MiddlewareChain<C, T>(options: ChainableOptions<C, T>): Generator<Middleware<C, T>, void, unknown>;
-type MiddlewareChain<C, T> = Iterator<Middleware<C, T>>;
-export declare function resolve<C, T>(middlewares: MiddlewareChain<C, T>, context: C): T;
-export {};
-//# sourceMappingURL=middleware.d.ts.map

package/vite/dist/src/model/built-ins.d.ts

@@ -1,3 +0,0 @@
-import { createModel } from '.';
-export default function registerBuiltIns(create: typeof createModel): void;
-//# sourceMappingURL=built-ins.d.ts.map

package/vite/dist/src/model/index.d.ts

@@ -1,21 +0,0 @@
-import { Constructor } from 'typescript-rtti';
-import { XMLModelOptions, XMLModelPropertyOptions, CreateXMLModelOptions } from './types';
-import { XMLRoot } from '../types';
-export declare function getParentModel(model: XMLModel<any>): XMLModel<any>;
-export declare class XMLModel<T = any> {
-    readonly type: Constructor<T>;
-    options: XMLModelOptions<T>;
-    constructor(type: Constructor<T>, options: CreateXMLModelOptions<T>);
-    fromXML(xml: XMLRoot | string): T;
-    toXML(instance: unknown): XMLRoot;
-    get reflectedClass(): import('typescript-rtti').ReflectedClass<Constructor<T>>;
-    resolveAllProperties(): Map<string, XMLModelPropertyOptions<any> & {
-        model: any;
-    }>;
-}
-export declare function createModel<T>(type: Constructor<T>, options: CreateXMLModelOptions<T>): XMLModel<T>;
-declare function ModelDecoratorFactory<T>(options?: CreateXMLModelOptions<T>): (constructor: Constructor<T>) => void;
-export { getModel } from './registry';
-export { ModelDecoratorFactory as Model };
-export { Prop } from './property';
-//# sourceMappingURL=index.d.ts.map

package/vite/dist/src/model/property.d.ts

@@ -1,6 +0,0 @@
-import { Constructor } from 'typescript-rtti';
-import { XMLModelProperty, XMLModelPropertyOptions, CreateXMLModelPropertyOptions } from './types';
-export declare function getPropertyConversionOptions<T>(constructor: Constructor<T>, property: XMLModelProperty<T>): XMLModelPropertyOptions<T>;
-declare function PropDecoratorFactory<T = any>(options?: CreateXMLModelPropertyOptions<T>): (prototype: any, property: XMLModelProperty<T>) => void;
-export { PropDecoratorFactory as Prop };
-//# sourceMappingURL=property.d.ts.map

package/vite/dist/src/model/registry.d.ts

@@ -1,9 +0,0 @@
-import { Constructor } from 'typescript-rtti';
-import { XMLModel } from '.';
-type ModelID<T> = Constructor<T>;
-export declare const Models: Map<ModelID<unknown>, XMLModel<unknown>>;
-export declare function registrerModel(model: XMLModel<unknown>): Map<ModelID<unknown>, XMLModel<unknown>>;
-export declare function findModel<T>(id: ModelID<T>): XMLModel<T> | undefined;
-export declare function getModel<T>(id: ModelID<T>): XMLModel<T>;
-export {};
-//# sourceMappingURL=registry.d.ts.map

package/vite/dist/src/model/types.d.ts

@@ -1,74 +0,0 @@
-import { ReflectedProperty } from 'typescript-rtti';
-import { XMLRoot, XMLElement } from '../types';
-import { Middleware } from '../middleware';
-import { XMLModel } from './index';
-export type XMLModelProperty<T> = Extract<keyof T, string>;
-export type PropertiesRecord<T> = {
-    [key in keyof T]?: T[key];
-};
-export type XMLPropertiesRecord<T> = {
-    [key in keyof T]?: XMLRoot;
-};
-export interface PropertyToXMLContext<T> extends Omit<toXMLContext<T>, "properties"> {
-    property: XMLModelPropertyOptions<T>;
-    value: T[keyof T];
-}
-export interface PropertyFromXMLContext<T> extends Omit<fromXMLContext<T>, "properties"> {
-    property: XMLModelPropertyOptions<T>;
-    elements: XMLElement[];
-}
-export interface XMLModelPropertyOptions<T> {
-    name: keyof T;
-    reflected: ReflectedProperty;
-    tagname: string;
-    ignored: boolean;
-    inline: boolean;
-    model?: XMLModel<any>;
-    isSourceElement: (element: XMLElement, context: Omit<PropertyFromXMLContext<T>, "elements">) => boolean;
-    resolveElements: (context: Omit<PropertyFromXMLContext<T>, "elements">) => XMLElement[];
-    fromXML: (context: PropertyFromXMLContext<T>) => T[keyof T];
-    toXML: (context: PropertyToXMLContext<T>) => XMLRoot;
-}
-export interface CreateXMLModelPropertyOptions<T> {
-    tagname?: string;
-    sourceElements?: string | RegExp | XMLModelPropertyOptions<T>["isSourceElement"];
-    resolveElements?: XMLModelPropertyOptions<T>["resolveElements"];
-    toXML?: XMLModelPropertyOptions<T>["toXML"];
-    fromXML?: XMLModelPropertyOptions<T>["fromXML"];
-    inline?: boolean;
-    ignore?: boolean;
-    model?: XMLModelPropertyOptions<T>["model"];
-}
-interface ConversionOptions<C, T> {
-    parent: ConversionOptions<C, T> | null;
-    middlewares: Middleware<C, T>[];
-}
-export interface fromXMLContext<T> {
-    xml: XMLRoot;
-    properties: PropertiesRecord<T>;
-    model: XMLModel<T>;
-}
-export interface toXMLContext<T> {
-    object: T;
-    properties: XMLPropertiesRecord<T>;
-    model: XMLModel<T>;
-}
-export interface XMLModelOptions<T> {
-    parent?: XMLModel<T>;
-    properties: {
-        fromXML: ConversionOptions<Omit<fromXMLContext<T>, "properties">, PropertiesRecord<T>>;
-        toXML: ConversionOptions<Omit<toXMLContext<T>, "properties">, XMLPropertiesRecord<T>>;
-        options: Map<XMLModelProperty<T>, XMLModelPropertyOptions<T>>;
-    };
-    fromXML: ConversionOptions<fromXMLContext<T>, T>;
-    toXML: ConversionOptions<toXMLContext<T>, XMLRoot>;
-    tagname: string;
-}
-export interface CreateXMLModelOptions<T> {
-    parent?: XMLModelOptions<T>["parent"];
-    fromXML?: XMLModelOptions<T>["fromXML"]["middlewares"][number];
-    toXML?: XMLModelOptions<T>["toXML"]["middlewares"][number];
-    tagname?: XMLModelOptions<T>["tagname"];
-}
-export { XMLModel };
-//# sourceMappingURL=types.d.ts.map

package/vite/dist/src/model.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=model.test.d.ts.map

package/vite/dist/src/types.d.ts

@@ -1,17 +0,0 @@
-export type { Constructor } from 'typescript-rtti';
-export type UnknownRecord = Record<string | number | symbol, unknown>;
-export type UnknownObject = object;
-export interface XMLAttributes {
-    [key: string]: string | number | undefined;
-}
-export interface XMLElement {
-    type?: string;
-    name?: string;
-    attributes?: XMLAttributes;
-    elements?: Array<XMLElement>;
-    text?: string | number | boolean;
-}
-export type XMLRoot = {
-    elements: XMLElement[];
-};
-//# sourceMappingURL=types.d.ts.map

package/vite/dist/src/util/is-regexp.d.ts

@@ -1,12 +0,0 @@
-/**
- * Stolen from https://github.com/sindresorhus/is-regexp/blob/main/index.js
- *
- * see https://github.com/sindresorhus/is#why-not-just-use-instanceof-instead-of-this-package
- *
- * could use `import { isRegExp } from "node:util/types"` but I want isomorphic lib
- * @param value
- * @returns
- */
-export declare function isRegExp(value: unknown): value is RegExp;
-export default isRegExp;
-//# sourceMappingURL=is-regexp.d.ts.map

package/vite/dist/src/util/kebab-case.d.ts

@@ -1,16 +0,0 @@
-/**
- * Transforms a string into kebab-case.
- *
- * stolen from https://github.com/joakimbeng/kebab-case/blob/master/index.js
- *
- * @example
- * kebabCase("helloWorld"); // "hello-world"
- * kebabCase("HelloWorld"); // "-hello-world"
- * kebabCase("HelloWorld", false); // "hello-world"
- *
- * @param str The string to transform
- * @param keepLeadingDash Whether to keep the leading dash in case the string starts with an uppercase letter (default: true)
- * @returns The kebab-cased string
- */
-export declare function kebabCase(str: string, keepLeadingDash?: boolean): string;
-//# sourceMappingURL=kebab-case.d.ts.map

package/vite/dist/src/util/merge-maps.d.ts

@@ -1,2 +0,0 @@
-export default function mergeMaps<K, V>(...sources: Map<K, V>[]): Map<K, V>;
-//# sourceMappingURL=merge-maps.d.ts.map

package/vite/dist/src/xml/index.d.ts

@@ -1,33 +0,0 @@
-import { XMLElement, XMLRoot } from '../types';
-export declare function parse(string: string): XMLRoot;
-export declare const stringify: typeof import('xml-js').js2xml;
-export declare function getContent(xml: XMLElement): string | number | boolean;
-export declare function fromContent(content: string): {
-    elements: [{
-        type: "text";
-        text: string;
-    }] | [];
-};
-export declare function fromContent(content: string, tag: string, attributes?: XMLElement["attributes"]): {
-    type: "element";
-    name: string;
-    attributes?: XMLElement["attributes"];
-    elements: [{
-        type: "text";
-        text: string;
-    }] | [];
-};
-export declare function addElement(xml: XMLElement, element: XMLElement): void;
-export declare function setAttribute(xml: XMLElement, attribute: string, value: string): void;
-export declare function deleteAttribute(xml: XMLElement, attribute: string): void;
-declare const XML: {
-    parse: typeof parse;
-    stringify: typeof import('xml-js').js2xml;
-    fromContent: typeof fromContent;
-    getContent: typeof getContent;
-    addElement: typeof addElement;
-    setAttribute: typeof setAttribute;
-    deleteAttribute: typeof deleteAttribute;
-};
-export default XML;
-//# sourceMappingURL=index.d.ts.map

package/vite/dist/src/xml/xml-js.d.ts

@@ -1,7 +0,0 @@
-import { xml2js as parse, js2xml as stringify } from 'xml-js';
-declare const _default: {
-    parse: typeof parse;
-    stringify: typeof stringify;
-};
-export default _default;
-//# sourceMappingURL=xml-js.d.ts.map