@plaudit/webpack-extensions 2.70.1 → 2.72.0

package/build/utils/php-writer.d.ts

@@ -1,237 +0,0 @@
-import { AssetInfo, Compilation } from "webpack";
-export declare abstract class Expr {
-    static readonly jsonToPHPConverter: (obj: unknown, parentIndent?: string) => string;
-    static readonly convertJsonToPHP: (obj: unknown) => string;
-    protected constructor();
-    abstract toString(): string;
-    typeName(): string;
-    static isset(...checks: (Var | ArrayAccess | ObjectAccess)[]): Call;
-    static call(name: string, args: ConstructorParameters<typeof Call>[1]): Call;
-}
-export interface EnclosableExpression extends Expr {
-    toEnclosedForm(): string;
-    not(): Not;
-}
-export interface PotentiallyWriteableExpression extends EnclosableExpression {
-    readonly potentiallyWritable: true;
-}
-export declare function isEnclosableExpression(a: unknown): a is EnclosableExpression;
-export declare function isPotentiallyWriteableExpression(a: unknown): a is PotentiallyWriteableExpression;
-export declare abstract class AbstractEnclosableExpression extends Expr implements EnclosableExpression {
-    static readonly closers: Readonly<{
-        "(": ")";
-        "[": "]";
-        "{": "}";
-    }>;
-    abstract toEnclosedForm(): string;
-    not(): Not;
-}
-export declare abstract class ParenthesesEnclosableExpression extends AbstractEnclosableExpression {
-    toEnclosedForm(): string;
-}
-export declare abstract class EnclosedExpression extends AbstractEnclosableExpression {
-    toEnclosedForm(): string;
-}
-export declare class Literal extends Expr {
-    readonly expression: string;
-    constructor(expression: string);
-    toString(): string;
-    static of(expression: string | PHPWriter, enclosed: true): EnclosedLiteral;
-    static of(expression: string | PHPWriter, enclosureOpen: keyof typeof AbstractEnclosableExpression.closers, encloserClose?: string): EnclosableLiteral;
-    static of(expression: string | PHPWriter, enclosureOpen: string, encloserClose: string): EnclosableLiteral;
-    static of(expression: string | PHPWriter, enclosed?: false | undefined): Literal;
-    static name(expression: string): EnclosedLiteral;
-}
-export declare class EnclosedLiteral extends Literal implements EnclosableExpression {
-    constructor(expression: string);
-    toEnclosedForm(): string;
-    not(): Not;
-}
-export declare class EnclosableLiteral extends Literal implements EnclosableExpression {
-    private readonly enclosureOpen;
-    private readonly enclosureClose;
-    constructor(expression: string, enclosureOpen: string, enclosureClose: string);
-    toEnclosedForm(): string;
-    not(): Not;
-}
-export declare class Var extends EnclosedExpression implements PotentiallyWriteableExpression {
-    readonly name: string;
-    readonly potentiallyWritable = true;
-    constructor(name: string);
-    toString(): string;
-}
-export declare class Op extends ParenthesesEnclosableExpression {
-    readonly operator: string;
-    readonly args: readonly unknown[];
-    constructor(operator: string, ...args: unknown[]);
-    toString(): string;
-    static binary(left: unknown, operator: string, right: unknown): Op;
-    static concat(...args: unknown[]): Op;
-}
-export declare class Not extends ParenthesesEnclosableExpression {
-    readonly expression: EnclosableExpression;
-    constructor(expression: EnclosableExpression);
-    toString(): string;
-}
-type AtLeastOneArray<T> = [T, ...T[]];
-type ReadonlyAtLeastOneArray<T> = readonly [T, ...T[]];
-export type Accessor = Expr | string | number;
-export type AccessorOrAccessorArray = Accessor | AtLeastOneArray<Accessor>;
-export declare abstract class Access extends EnclosedExpression implements PotentiallyWriteableExpression {
-    readonly target: EnclosableExpression;
-    readonly potentiallyWritable = true;
-    readonly accesses: ReadonlyAtLeastOneArray<Accessor>;
-    constructor(target: EnclosableExpression, accesses: AccessorOrAccessorArray);
-    abstract endsWithCall(): boolean;
-    abstract endsWithPotentiallyWritableExpression(): boolean;
-}
-export declare class ArrayAccess extends Access {
-    toString(): string;
-    endsWithCall(): boolean;
-    endsWithPotentiallyWritableExpression(): boolean;
-}
-export declare class ObjectAccess extends Access {
-    static readonly validObjectKey: RegExp;
-    toString(): string;
-    endsWithCall(): boolean;
-    endsWithPotentiallyWritableExpression(): boolean;
-}
-export declare class Call extends EnclosedExpression implements PotentiallyWriteableExpression {
-    readonly callee: string | EnclosableExpression;
-    readonly args: readonly unknown[];
-    readonly potentiallyWritable = true;
-    constructor(callee: string | EnclosableExpression, args: readonly unknown[]);
-    toString(): string;
-}
-export declare class Parameter extends Expr {
-    readonly value: unknown;
-    readonly name?: string | undefined;
-    constructor(value: unknown, name?: string | undefined);
-    toString(): string;
-}
-export declare class FirstClassCallable extends ParenthesesEnclosableExpression {
-    readonly name: EnclosableExpression;
-    constructor(name: EnclosableExpression);
-    static from(literal: string): FirstClassCallable;
-    toString(): string;
-}
-export declare const validPHPLabel: RegExp;
-type Assignable = EnclosedExpression & PotentiallyWriteableExpression;
-export declare class Assignment extends ParenthesesEnclosableExpression {
-    readonly value: unknown;
-    readonly push: boolean;
-    readonly assignees: ReadonlyAtLeastOneArray<Assignable>;
-    constructor(assignees: Assignable, value: unknown, push: true);
-    constructor(assignees: Assignable | AtLeastOneArray<Assignable>, value: unknown, push?: false | undefined);
-    toString(): string;
-}
-export declare abstract class Constants {
-    static readonly __FILE__: EnclosedLiteral;
-    static readonly __DIR__: EnclosedLiteral;
-    static readonly ABSPATH: EnclosedLiteral;
-}
-export type AppendExprArgs = {
-    chain?: boolean;
-    return?: boolean;
-};
-export type ActionOrFilterArgs = {
-    priority?: number | Expr;
-    functionArgParameters?: string[];
-    useVars?: Var[];
-    accountForAlreadyDoing?: boolean | Parameters<PHPWriter['call']>[1];
-};
-export type FunctionCreationArgs = {
-    includeExistenceCheck?: boolean;
-    useVars?: Var[];
-    returnType?: string;
-    assignToName?: boolean;
-    scopeActionDescription?: string;
-};
-export type RequireOrIncludeArgs = {
-    dirRelative?: boolean;
-    once?: boolean;
-} & AppendExprArgs;
-export declare class PHPWriter {
-    private readonly inlineFirstLine;
-    private readonly scopeStack;
-    private readonly useList;
-    private readonly allocatedGeneratedFunctionNames;
-    private readonly isSubwriter;
-    private printingInPHP;
-    private buffer;
-    private indentation;
-    private fileNamespace;
-    private myOpenedScopes;
-    constructor(inlineFirstLine?: boolean, scopeStack?: string[][], useList?: string[], allocatedGeneratedFunctionNames?: Set<string>, isSubwriter?: boolean, printingInPHP?: boolean, initialIndentation?: number);
-    createSubwriter(): PHPWriter;
-    indent(): this;
-    outdent(): this;
-    setIndentation(level: number): this;
-    /**
-     * @param lines These are treated as literal *regardless of their types*
-     */
-    append(...lines: (string | Expr)[]): this;
-    /**
-     * @param expr This is treated as literal *regardless of its type*
-     * @param opts flags to add additional markup around the expression
-     */
-    appendExpr(expr: string | Expr, opts?: AppendExprArgs): this;
-    assign(assignee: ConstructorParameters<typeof Assignment>[0] | string, expression: unknown, opts?: AppendExprArgs): this;
-    return(expression: unknown | Expr): this;
-    static(variable: Var | string, opts?: {
-        initializer?: unknown | Literal;
-        withTest?: boolean | 'chainable';
-    }): this;
-    linebreak(): this;
-    /**
-     * @param func This is treated as literal *regardless of its type*
-     * @param args
-     * @param opts
-     */
-    call(func: string | EnclosableExpression, args: unknown[], opts?: {
-        assignTo?: ConstructorParameters<typeof Assignment>[0];
-    } & AppendExprArgs): this;
-    action(name: string | Expr, contents: (writer: PHPWriter) => void, args?: ActionOrFilterArgs): this;
-    filter(name: string | Expr, contents: (writer: PHPWriter) => void, args?: ActionOrFilterArgs): this;
-    actionOrFilter(type: 'action' | 'filter', name: string | Expr, contents: (writer: PHPWriter) => void, args: ActionOrFilterArgs): this;
-    if(condition: Expr): this;
-    elseIf(condition: Expr): this;
-    else(): this;
-    endIf(): this;
-    function(name: true, parameters: (string | Var)[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): Var;
-    function(name: string | Var | false, parameters: (string | Var)[], body: (writer: PHPWriter) => void, args?: FunctionCreationArgs): this;
-    generateFunctionName(asVariable: true): Var;
-    generateFunctionName(asVariable?: false | undefined): string;
-    generateFunctionName(asVariable?: boolean): string | Var;
-    closePHP(): this;
-    openPHP(): this;
-    namespace(namespace: string): this;
-    use(...uses: string[]): this;
-    require(filePath: string | Expr, args?: RequireOrIncludeArgs): this;
-    include(filePath: string | Expr, args?: RequireOrIncludeArgs): this;
-    requireOrInclude(type: 'require' | 'include', filePath: string | Expr, args: RequireOrIncludeArgs): this;
-    /**
-     * Starts a scope that, when paired with {@link #closeScope()}, allows for automating unset calls.
-     * All scopes started MUST be paired with either an {@link #closeScope()} or {@link #popScope()} call.
-     */
-    openScope(): this;
-    /**
-     * Pops the top scope from the stack AND unsets all variables that were assigned within it
-     */
-    closeScope(): this;
-    /**
-     * Pops the top scope from the stack WITHOUT calling unset for the variables that were assigned within it.
-     * This is used to allow function bodies to be safely created without disrupting their containing scope.
-     */
-    popScope(): this;
-    withScope(code: (writer: PHPWriter) => void, opts?: {
-        actionDescription?: string;
-        usePopScopeInstead?: boolean;
-    }): this;
-    toString(args?: {
-        includeOpenPHP?: boolean;
-        includeNamespaceAndUse?: boolean;
-    }): string;
-    emitAsset(compilation: Compilation, file: string, assetInfo?: AssetInfo): void;
-}
-export {};